WxWidgets || Dodanie nowej klasy oraz metod do obsługi operacji

Cześć, próbuję dodać nową klasę która swoimi metodami wykonywała by odpowiednio dodawanie, odejmowanie, mnożenie oraz dzielenie liczb zespolonych.
Niestety ciągle wyskakuje mi błąd TextCtrl1 was not declared in this scope.

struct Zespolona
{
    double rzeczywista;
    double urojona;
};

class Obliczenia{
    void dodaj(){
     
     Zespolona przycisk1_1;
        Zespolona przycisk1_2;
        int wynik1;
        int wynik2;
        char* znak;
        wxString wynik;

        if(TextCtrl1->GetValue().ToDouble(&przycisk1_1.rzeczywista) && TextCtrl2->GetValue().ToDouble(&przycisk1_1.urojona)
                && TextCtrl3->GetValue().ToDouble(&przycisk1_2.rzeczywista) && TextCtrl4->GetValue().ToDouble(&przycisk1_2.urojona))
        {
            wynik1 = (przycisk1_1.rzeczywista - przycisk1_2.rzeczywista);
            wynik2 = (przycisk1_1.urojona + przycisk1_2.urojona);
            if(wynik2>=0)
            {
                znak="+";
            }
            wynik << wynik1<<znak<<wynik2<<"i";
            TextCtrl5->SetValue(wynik);
        }
    }
};
void Zad2Frame::OnButton1Click(wxCommandEvent& event)
{
       dodaj();
}

Problem jest dokładnie taki jak go raportuje kompilator: nie wiadomo co to jest TextCtrl1, nie jest nigdzie zdefiniowane.

TextCtrl1 jest zdefiniowane w klasie Zad2frame, mogę podrzucić kod. Moje pytanie brzmi - jak zaciągnąć zmienną zadeklarowaną w klasie Zad2frame do innej klasy, np. klasy Obliczenia?

Przenieść funkcję dodaj() z klasy Obliczenia do klasy Zad2frame.

Nie mogę tak zrobić, w poleceniu jest żeby utworzyć osobną klasę Obliczenia z jej metodami, np. dodaj();

Jak jest treść zadania?
Poza tym pokaż całość kodu.

Treść zadania

W przypadku kalkulatora liczb zespolonych może to być na przykład struktura o
nazwie Zespolona umożliwiająca przy pomocy dwóch pól typu double zdefiniowanie części
rzeczywistej i urojonej liczby zespolonej oraz klasa o nazwie Obliczenia, która przy pomocy
struktury Zespolona realizuje w odpowiednich metodach podstawowe operacje matematyczne
wykonywane na liczbach zespolonych typu Zespolona.
Przykładowo klasa (Obliczenia) wraz ze strukturą (Zespolona) może się znajdować w
pliku o nazwie
Zespolone.h
który dołączymy dyrektywą
#include ''Zespolone.h''
do pliku o nazwie
kalkulatorMain.h
oczywiście przy założeniu, że projekt nazywa się kalkulator wobec tego podstawowe
pliki projektu otrzymają nazwy: kalkulatorApp.h, kalkulatorApp.cpp, kalkulatorMain.h oraz
kalkulatorMain.cpp.
Jeśli teraz chcielibyśmy w pliku głównym aplikacji powołać do życia obiekt o nazwie
Oblicz będący instancją klasy Obliczenia czyli
Obliczenia Oblicz;
najlepiej zrobić to w pliku kalkulatorMain.h w ciele klasy kalkulatorFrame
dziedziczącej po klasie wxFrame w części prywatnej. Oczywiście plik Zesplone.h powinien
znajdować się w katalogu projektu kalkulator środowiska Code::Blocks

Zad2Main.cpp

#include "Zad2Main.h"
#include <wx/msgdlg.h>
#include "Zespolone.h"

//(*InternalHeaders(Zad2Frame)
#include <wx/intl.h>
#include <wx/settings.h>
#include <wx/string.h>
//*)

//helper functions
enum wxbuildinfoformat {
    short_f, long_f };

wxString wxbuildinfo(wxbuildinfoformat format)
{
    wxString wxbuild(wxVERSION_STRING);

    if (format == long_f )
    {
#if defined(__WXMSW__)
        wxbuild << _T("-Windows");
#elif defined(__UNIX__)
        wxbuild << _T("-Linux");
#endif

#if wxUSE_UNICODE
        wxbuild << _T("-Unicode build");
#else
        wxbuild << _T("-ANSI build");
#endif // wxUSE_UNICODE
    }

    return wxbuild;
}

//(*IdInit(Zad2Frame)
const long Zad2Frame::ID_STATICTEXT1 = wxNewId();
const long Zad2Frame::ID_TEXTCTRL1 = wxNewId();
const long Zad2Frame::ID_STATICTEXT2 = wxNewId();
const long Zad2Frame::ID_TEXTCTRL2 = wxNewId();
const long Zad2Frame::ID_STATICTEXT3 = wxNewId();
const long Zad2Frame::ID_TEXTCTRL3 = wxNewId();
const long Zad2Frame::ID_STATICTEXT4 = wxNewId();
const long Zad2Frame::ID_TEXTCTRL4 = wxNewId();
const long Zad2Frame::ID_BUTTON1 = wxNewId();
const long Zad2Frame::ID_BUTTON2 = wxNewId();
const long Zad2Frame::ID_BUTTON3 = wxNewId();
const long Zad2Frame::ID_BUTTON4 = wxNewId();
const long Zad2Frame::ID_TEXTCTRL5 = wxNewId();
const long Zad2Frame::idMenuQuit = wxNewId();
const long Zad2Frame::idMenuAbout = wxNewId();
const long Zad2Frame::ID_STATUSBAR1 = wxNewId();
//*)

BEGIN_EVENT_TABLE(Zad2Frame,wxFrame)
    //(*EventTable(Zad2Frame)
    //*)
END_EVENT_TABLE()

Zad2Frame::Zad2Frame(wxWindow* parent,wxWindowID id)
{
    //(*Initialize(Zad2Frame)
    wxBoxSizer* BoxSizer1;
    wxBoxSizer* BoxSizer2;
    wxGridSizer* GridSizer1;
    wxGridSizer* GridSizer2;
    wxGridSizer* GridSizer3;
    wxGridSizer* GridSizer4;
    wxMenu* Menu1;
    wxMenu* Menu2;
    wxMenuBar* MenuBar1;
    wxMenuItem* MenuItem1;
    wxMenuItem* MenuItem2;
    wxStaticBoxSizer* StaticBoxSizer1;
    wxStaticBoxSizer* StaticBoxSizer2;
    wxStaticBoxSizer* StaticBoxSizer3;
    wxStaticBoxSizer* StaticBoxSizer4;
    wxStaticBoxSizer* StaticBoxSizer5;

    Create(parent, wxID_ANY, _("Kalkulator liczb zespolonych"), wxDefaultPosition, wxDefaultSize, wxDEFAULT_FRAME_STYLE, _T("wxID_ANY"));
    SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_MENU));
    BoxSizer1 = new wxBoxSizer(wxHORIZONTAL);
    StaticBoxSizer1 = new wxStaticBoxSizer(wxHORIZONTAL, this, _("Dane"));
    GridSizer1 = new wxGridSizer(2, 1, 0, 0);
    StaticBoxSizer3 = new wxStaticBoxSizer(wxHORIZONTAL, this, _("Pierwsza liczba"));
    GridSizer3 = new wxGridSizer(2, 2, 0, 0);
    StaticText1 = new wxStaticText(this, ID_STATICTEXT1, _("Rzeczywista"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT1"));
    GridSizer3->Add(StaticText1, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
    TextCtrl1 = new wxTextCtrl(this, ID_TEXTCTRL1, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_TEXTCTRL1"));
    GridSizer3->Add(TextCtrl1, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
    StaticText2 = new wxStaticText(this, ID_STATICTEXT2, _("Urojona"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT2"));
    GridSizer3->Add(StaticText2, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
    TextCtrl2 = new wxTextCtrl(this, ID_TEXTCTRL2, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_TEXTCTRL2"));
    GridSizer3->Add(TextCtrl2, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
    StaticBoxSizer3->Add(GridSizer3, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
    GridSizer1->Add(StaticBoxSizer3, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
    StaticBoxSizer4 = new wxStaticBoxSizer(wxHORIZONTAL, this, _("Druga liczba"));
    GridSizer4 = new wxGridSizer(2, 2, 0, 0);
    StaticText3 = new wxStaticText(this, ID_STATICTEXT3, _("Rzeczywista"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT3"));
    GridSizer4->Add(StaticText3, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
    TextCtrl3 = new wxTextCtrl(this, ID_TEXTCTRL3, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_TEXTCTRL3"));
    GridSizer4->Add(TextCtrl3, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
    StaticText4 = new wxStaticText(this, ID_STATICTEXT4, _("Urojona"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT4"));
    GridSizer4->Add(StaticText4, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
    TextCtrl4 = new wxTextCtrl(this, ID_TEXTCTRL4, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_TEXTCTRL4"));
    GridSizer4->Add(TextCtrl4, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
    StaticBoxSizer4->Add(GridSizer4, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
    GridSizer1->Add(StaticBoxSizer4, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
    StaticBoxSizer1->Add(GridSizer1, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
    BoxSizer1->Add(StaticBoxSizer1, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
    StaticBoxSizer2 = new wxStaticBoxSizer(wxHORIZONTAL, this, _("Operacje"));
    GridSizer2 = new wxGridSizer(3, 2, 0, 0);
    Button1 = new wxButton(this, ID_BUTTON1, _("+"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_BUTTON1"));
    GridSizer2->Add(Button1, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
    Button2 = new wxButton(this, ID_BUTTON2, _("-"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_BUTTON2"));
    GridSizer2->Add(Button2, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
    Button3 = new wxButton(this, ID_BUTTON3, _("*"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_BUTTON3"));
    GridSizer2->Add(Button3, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
    Button4 = new wxButton(this, ID_BUTTON4, _("/"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_BUTTON4"));
    GridSizer2->Add(Button4, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
    StaticBoxSizer5 = new wxStaticBoxSizer(wxHORIZONTAL, this, _("Wynik"));
    BoxSizer2 = new wxBoxSizer(wxHORIZONTAL);
    TextCtrl5 = new wxTextCtrl(this, ID_TEXTCTRL5, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY, wxDefaultValidator, _T("ID_TEXTCTRL5"));
    BoxSizer2->Add(TextCtrl5, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
    StaticBoxSizer5->Add(BoxSizer2, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
    GridSizer2->Add(StaticBoxSizer5, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
    StaticBoxSizer2->Add(GridSizer2, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
    BoxSizer1->Add(StaticBoxSizer2, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
    SetSizer(BoxSizer1);
    MenuBar1 = new wxMenuBar();
    Menu1 = new wxMenu();
    MenuItem1 = new wxMenuItem(Menu1, idMenuQuit, _("Wyjscie\tAlt-F4"), _("Wyjdz z aplikacji"), wxITEM_NORMAL);
    Menu1->Append(MenuItem1);
    MenuBar1->Append(Menu1, _("&Plik"));
    Menu2 = new wxMenu();
    MenuItem2 = new wxMenuItem(Menu2, idMenuAbout, _("Informacje\tF1"), _("Wyœwietl informacje o aplikacji"), wxITEM_NORMAL);
    Menu2->Append(MenuItem2);
    MenuBar1->Append(Menu2, _("Pomoc"));
    SetMenuBar(MenuBar1);
    StatusBar1 = new wxStatusBar(this, ID_STATUSBAR1, 0, _T("ID_STATUSBAR1"));
    int __wxStatusBarWidths_1[1] = { -1 };
    int __wxStatusBarStyles_1[1] = { wxSB_NORMAL };
    StatusBar1->SetFieldsCount(1,__wxStatusBarWidths_1);
    StatusBar1->SetStatusStyles(1,__wxStatusBarStyles_1);
    SetStatusBar(StatusBar1);
    BoxSizer1->Fit(this);
    BoxSizer1->SetSizeHints(this);

    Connect(ID_BUTTON1,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&Zad2Frame::OnButton1Click);
    Connect(ID_BUTTON2,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&Zad2Frame::OnButton2Click);
    Connect(ID_BUTTON3,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&Zad2Frame::OnButton3Click);
    Connect(ID_BUTTON4,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&Zad2Frame::OnButton4Click);
    Connect(idMenuQuit,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&Zad2Frame::OnQuit);
    Connect(idMenuAbout,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&Zad2Frame::OnAbout);
    //*)
}

Zad2Frame::~Zad2Frame()
{
    //(*Destroy(Zad2Frame)
    //*)
}

void Zad2Frame::OnQuit(wxCommandEvent& event)
{
    Close();
}

void Zad2Frame::OnAbout(wxCommandEvent& event)
{
    wxString msg = (msg, _("Wersja 0.1 Alpha ~ Wojciech Koziol 2k20"));
    wxMessageBox(msg, _("Kalkulator liczb zespolonych"));
}

Zad2Main.h

#ifndef ZAD2MAIN_H
#define ZAD2MAIN_H


//(*Headers(Zad2Frame)
#include <wx/button.h>
#include <wx/frame.h>
#include <wx/menu.h>
#include <wx/sizer.h>
#include <wx/stattext.h>
#include <wx/statusbr.h>
#include <wx/textctrl.h>
//*)

class Zad2Frame: public wxFrame
{
    public:

        Zad2Frame(wxWindow* parent,wxWindowID id = -1);
        virtual ~Zad2Frame();


        //(*Handlers(Zad2Frame)
        void OnQuit(wxCommandEvent& event);
        void OnAbout(wxCommandEvent& event);
        void OnTextCtrl1Text(wxCommandEvent& event);
        void OnButton1Click(wxCommandEvent& event);
        void OnButton2Click(wxCommandEvent& event);
        void OnButton3Click(wxCommandEvent& event);
        void OnButton4Click(wxCommandEvent& event);
        void OnTextCtrl6Text(wxCommandEvent& event);
        //*)

        //(*Identifiers(Zad2Frame)
        static const long ID_STATICTEXT1;
        static const long ID_TEXTCTRL1;
        static const long ID_STATICTEXT2;
        static const long ID_TEXTCTRL2;
        static const long ID_STATICTEXT3;
        static const long ID_TEXTCTRL3;
        static const long ID_STATICTEXT4;
        static const long ID_TEXTCTRL4;
        static const long ID_BUTTON1;
        static const long ID_BUTTON2;
        static const long ID_BUTTON3;
        static const long ID_BUTTON4;
        static const long ID_TEXTCTRL5;
        static const long idMenuQuit;
        static const long idMenuAbout;
        static const long ID_STATUSBAR1;
        //*)

        //(*Declarations(Zad2Frame)
        wxButton* Button1;
        wxButton* Button2;
        wxButton* Button3;
        wxButton* Button4;
        wxStaticText* StaticText1;
        wxStaticText* StaticText2;
        wxStaticText* StaticText3;
        wxStaticText* StaticText4;
        wxStatusBar* StatusBar1;
        wxTextCtrl* TextCtrl1;
        wxTextCtrl* TextCtrl2;
        wxTextCtrl* TextCtrl3;
        wxTextCtrl* TextCtrl4;
        wxTextCtrl* TextCtrl5;
        //*)

        DECLARE_EVENT_TABLE()
};

#endif // ZAD2MAIN_H

Zad2App.cpp

#include "Zad2App.h"

//(*AppHeaders
#include "Zad2Main.h"
#include <wx/image.h>
//*)

IMPLEMENT_APP(Zad2App);

bool Zad2App::OnInit()
{
    //(*AppInitialize
    bool wxsOK = true;
    wxInitAllImageHandlers();
    if ( wxsOK )
    {
    	Zad2Frame* Frame = new Zad2Frame(0);
    	Frame->Show();
    	SetTopWindow(Frame);
    }
    //*)
    return wxsOK;

}

Zespolone.h

#ifndef ZESPOLONE_H_INCLUDED
#define ZESPOLONE_H_INCLUDED

#endif // ZESPOLONE_H_INCLUDED

struct Zespolona
{
    double rzeczywista;
    double urojona;
};

class Obliczenia{
    void dodaj(){

     Zespolona przycisk1_1;
        Zespolona przycisk1_2;
        int wynik1;
        int wynik2;
        char* znak;
        wxString wynik;

        if(TextCtrl1->GetValue().ToDouble(&przycisk1_1.rzeczywista) && TextCtrl2->GetValue().ToDouble(&przycisk1_1.urojona)
                && TextCtrl3->GetValue().ToDouble(&przycisk1_2.rzeczywista) && TextCtrl4->GetValue().ToDouble(&przycisk1_2.urojona))
        {
            wynik1 = (przycisk1_1.rzeczywista - przycisk1_2.rzeczywista);
            wynik2 = (przycisk1_1.urojona + przycisk1_2.urojona);
            if(wynik2>=0)
            {
                znak="+";
            }
            wynik << wynik1<<znak<<wynik2<<"i";
            TextCtrl5->SetValue(wynik);
        }
    }
};
void Zad2Frame::OnButton1Click(wxCommandEvent& event)
{
       dodaj();
}

void Zad2Frame::OnButton2Click(wxCommandEvent& event)
{
    Zespolona przycisk1_1;
    Zespolona przycisk1_2;
    int wynik1;
    int wynik2;
    char* znak;
    wxString wynik;

    if(TextCtrl1->GetValue().ToDouble(&przycisk1_1.rzeczywista) && TextCtrl2->GetValue().ToDouble(&przycisk1_1.urojona)
            && TextCtrl3->GetValue().ToDouble(&przycisk1_2.rzeczywista) && TextCtrl4->GetValue().ToDouble(&przycisk1_2.urojona))
    {
        wynik1 = (przycisk1_1.rzeczywista - przycisk1_2.rzeczywista);
        wynik2 = (przycisk1_1.urojona + przycisk1_2.urojona);
        if(wynik2>=0)
        {
            znak="+";
        }
        wynik << wynik1<<znak<<wynik2<<"i";
        TextCtrl5->SetValue(wynik);
    }
}

void Zad2Frame::OnButton3Click(wxCommandEvent& event)
{
    Zespolona przycisk1_1;
    Zespolona przycisk1_2;
    int wynik1;
    int wynik2;
    char* znak;
    wxString wynik;

    if(TextCtrl1->GetValue().ToDouble(&przycisk1_1.rzeczywista) && TextCtrl2->GetValue().ToDouble(&przycisk1_1.urojona)
            && TextCtrl3->GetValue().ToDouble(&przycisk1_2.rzeczywista) && TextCtrl4->GetValue().ToDouble(&przycisk1_2.urojona))
    {
        wynik1 = (przycisk1_1.rzeczywista * przycisk1_2.rzeczywista);
        wynik2 = (przycisk1_1.urojona * przycisk1_2.urojona);
        if(wynik2>=0)
        {
            znak="+";
        }
        wynik << wynik1<<znak<<wynik2<<"i";
        TextCtrl5->SetValue(wynik);
    }
}

void Zad2Frame::OnButton4Click(wxCommandEvent& event)
{
    Zespolona przycisk1_1;
    Zespolona przycisk1_2;
    int wynik1;
    int wynik2;
    char* znak;
    wxString wynik;

    if(TextCtrl1->GetValue().ToDouble(&przycisk1_1.rzeczywista) && TextCtrl2->GetValue().ToDouble(&przycisk1_1.urojona)
            && TextCtrl3->GetValue().ToDouble(&przycisk1_2.rzeczywista) && TextCtrl4->GetValue().ToDouble(&przycisk1_2.urojona))
    {
        wynik1 = (przycisk1_1.rzeczywista / przycisk1_2.rzeczywista);
        wynik2 = (przycisk1_1.urojona / przycisk1_2.urojona);
        if(wynik2>=0)
        {
            znak="+";
        }
        wynik << wynik1<<znak<<wynik2<<"i";
        TextCtrl5->SetValue(wynik);
    }
}

W ogóle, niech ta klasa obliczenia (trochę głupie, że to klasa, ale skoro ćwiczenie to ćwiczenie) przyjmuje wartości double a nie próbuje operować na interfejsie użytkownika. Kod realizujący obliczenia nie powinien odpowiadać za interakcję z użytkownikiem/operacje wejścia/wyjścia

Masz na myśli wartości double rzeczywista,urojona znajdujące się już w strukturze Zespolona?

TextCtrl1 masz zdefiniowane w Zad2Frame, a próbujesz go użyć w klasie Obliczenia.
Nie dość, że scope jest nie ten, to na dodatek Obliczenia nie powinno mieć jakiegokolwiek dostępu (wiedzy) do Zad2Frame, które jest elementem UI.

Tak jak ci kq pisze, klasy związane z UI są odpowiedzialne za prezentowanie danych i pobieranie ich od użytkownika i na tym powinna kończyć się ich rola.

W zadaniu jest sugestia aby wszystkie obliczenia były zawarte w klasie Obliczenia, w której nie powinno znajdować się nic więcej (żadne przyciski typu TextCtrl1).
Można to zrobić w ten sposób.

struct Complex
{
    double re {0.0};
    double im {0.0};
};

class Calculation
{
public:
    Complex add( const Complex& a , const Complex& b )
    {
        return { a.re + b.re , a.im + b.im };
    }
   ......
};

I następnie obiekt klasy Calculation utworzyć w klasie Zad2Frame.

Dodałem metody do klasy Obliczenia:

class Obliczenia
{
public:
    Zespolona suma( const Zespolona& a , const Zespolona& b )
    {
        return { a.re + b.re , a.im + b.im };
    }

    Zespolona roznica( const Zespolona& a , const Zespolona& b )
    {
        return { a.re - b.re , a.im + b.im };
    }

    Zespolona iloczyn( const Zespolona& a , const Zespolona& b )
    {
        return { a.re * b.re , a.im * b.im };
    }

    Zespolona iloraz( const Zespolona& a , const Zespolona& b )
    {
        return { a.re / b.re , a.im / b.im };
    }
};

W pliku Zad2Main.cpp dodałem obiekt klasy Obliczenia:

Zad2Frame::Zad2Frame(wxWindow* parent,wxWindowID id)
{
    Obliczenia oblicz;

Teraz próbując odwołać się do np. oblicz.suma() wyskakuje mi błąd "was not declared in this scope"
Gdzie powinienem zadeklarować ten obiekt?

Dla mnie to overkill. Nie ma co kombinować: https://godbolt.org/z/T46bPG

teraz próbując odwołać się do np. oblicz.suma() wyskakuje mi błąd "was not declared in this scope"

Nie przekazujesz żadnych parametrów do metody suma, która oczekuje dwóch obiektów typu Zespolona.

Zespolona liczba1 {5,-5};  // liczba1.re = 5 , liczba1.im = -5
Zespolona liczba2 {2,10}; // liczba2.re = 2 , liczba2.im = 10

Zespolona liczba_suma = oblicz.suma(liczba1,liczba2); // liczba_suma.re = 7 ,  liczba_suma.im = 5

Rozumiem, jak mógłbym przekazywać tam wartości wpisanie w pola tekstowe np. TextCtrl1?