Wyświetlanie wartości w TextCtrl5

Cześć, próbuję wyświetlić wartość Zespolona liczba_suma w TextCtrl5, niestety wyskakują mi błędy.

Kod:

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

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 };
    }
};

void Zad2Frame::OnButton1Click(wxCommandEvent& event)
{
    Obliczenia oblicz;
    wxString rzecz1 = TextCtrl1->GetValue();
    wxString uroj1 = TextCtrl2->GetValue();
    wxString rzecz2 = TextCtrl3->GetValue();
    wxString uroj2 = TextCtrl4->GetValue();
    double drzecz1 = atof(rzecz1);
    double duroj1 = atof(uroj1);
    double drzecz2 = atof(rzecz2);
    double duroj2 = atof(uroj2);

    Zespolona rzeczywiste {drzecz1,drzecz2};
    Zespolona urojone {duroj1,duroj2};
    Zespolona liczba_suma = oblicz.suma(rzeczywiste,urojone);
    wxString suma = Zespolona liczba_suma;
    TextCtrl5->SetValue(liczba_suma);
}

Jakie to błędy wyskakują, jak rozumiem, to mamy się domyślić?

Swoją drogą: wiesz co to są liczby zespolone? Jakim cudem chcesz mieć jedną złożoną z dwóch składników rzeczywistych a drugą wyłącznie z urojonych?

Borze ... jakie błędy? Sądzisz, ze my mamy szklaną kulę?

A jak widzę nazwy kontrolek nnnnnN a nie IlośćJabłekEdit IlośćGruszekEdit to mi się scyzoryk sam otwiera

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

Dzielenie też niepoprawnie ale nie będzie to jeden wiersz :D

TextCtrl5->SetValue("tu musi być napisi nie może to być liczba czy też klasa");

string to_string(const Zespolona &z)
{
	stringstream sout;
	sout<<z.re;
	if(z.im)
	{
		sout<<showpos<<im<<'i';
	}
	return sout.str();
}

TextCtrl5->SetValue(to_string(liczba_suma));

**TextCtrl5 **jest wskaźnikiem do obiektu klasy wxTextCtrl wykorzystującego "wewnątrznie" wxString, który powinien być parameterem **setValue ** ( a nie obiekt typu Zespolona ).
Możesz skorzystać z następującej konwersji.

wxString name = wxString::Format( wxT("%f+%f"), liczba_suma.re,liczba_suma.im );

Tak, mój bląd, miałem później dorzucić błąd kompilatora - zapomniałem.

Dziękuję za odpowiedzi, teraz wynik wyświetla się w jednej linii ale niestety jest błędny.

Program przerabiałem z kodu źródłowego który działał bez dodatkowych klas oraz struktur - wtedy działał idealnie.

W czym jest problem?

Dziękuję za pomoc, proszę o zamknięcie tematu.

Tacoo napisał(a):

Dziękuję za pomoc, proszę o zamknięcie tematu.

Temat zamknięty ;-)

    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 };
    }

Co to ma być? Używałeś kiedyś liczb zespolonych?
Powinieneś najpierw doczytać, na czym polegają liczby zespolone.

Powinno być:

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

    Zespolona iloraz( const Zespolona& a, const Zespolona& b )
    {
        auto b2 = b.re * b.re + b.im * b.im;
        return { (a.re * b.re + a.im * b.im)/b2,  (-a.re * b.im + a.im * b.re)/b2};
    }

Oto kod wynikowy.
Nie twierdzę że jest idealny, po prostu działa.

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

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,  a.re * b.im + a.im * b.re};
    }

    Zespolona iloraz( const Zespolona& a, const Zespolona& b )
    {
        auto b2 = b.re * b.re + b.im * b.im;
        return { (a.re * b.re + a.im * b.im)/b2,  (-a.re * b.im + a.im * b.re)/b2};
    }
};

void Zad2Frame::OnButton1Click(wxCommandEvent& event)
{
    Obliczenia oblicz;
    wxString rzecz1 = TextCtrl1->GetValue();
    wxString uroj1 = TextCtrl2->GetValue();
    wxString rzecz2 = TextCtrl3->GetValue();
    wxString uroj2 = TextCtrl4->GetValue();
    double drzecz1 = atof(rzecz1);
    double duroj1 = atof(uroj1);
    double drzecz2 = atof(rzecz2);
    double duroj2 = atof(uroj2);

    Zespolona rzeczywiste {drzecz1,drzecz2};
    Zespolona urojone {duroj1,duroj2};
    Zespolona liczba_suma = oblicz.suma(rzeczywiste,urojone);
    wxString wynik;

    wynik.Printf("%.1f %.1fi",  liczba_suma.re, liczba_suma.im);
    TextCtrl5->SetValue(wynik );
}

void Zad2Frame::OnButton2Click(wxCommandEvent& event)
{
    Obliczenia oblicz;
    wxString rzecz1 = TextCtrl1->GetValue();
    wxString uroj1 = TextCtrl2->GetValue();
    wxString rzecz2 = TextCtrl3->GetValue();
    wxString uroj2 = TextCtrl4->GetValue();
    double drzecz1 = atof(rzecz1);
    double duroj1 = atof(uroj1);
    double drzecz2 = atof(rzecz2);
    double duroj2 = atof(uroj2);

    Zespolona rzeczywiste {drzecz1,drzecz2};
    Zespolona urojone {duroj1,duroj2};
    Zespolona liczba_roznica = oblicz.roznica(rzeczywiste,urojone);
    wxString wynik;
    wynik.Printf("%.1f %.1fi",  liczba_roznica.re, liczba_roznica.im);
    TextCtrl5->SetValue(wynik );
}


void Zad2Frame::OnButton3Click(wxCommandEvent& event)
{
    Obliczenia oblicz;
    wxString rzecz1 = TextCtrl1->GetValue();
    wxString uroj1 = TextCtrl2->GetValue();
    wxString rzecz2 = TextCtrl3->GetValue();
    wxString uroj2 = TextCtrl4->GetValue();
    double drzecz1 = atof(rzecz1);
    double duroj1 = atof(uroj1);
    double drzecz2 = atof(rzecz2);
    double duroj2 = atof(uroj2);

    Zespolona rzeczywiste {drzecz1,drzecz2};
    Zespolona urojone {duroj1,duroj2};
    Zespolona liczba_iloczyn = oblicz.iloczyn(rzeczywiste,urojone);
    wxString wynik;
    wynik.Printf("%.1f %.1fi",  liczba_iloczyn.re, liczba_iloczyn.im);
    TextCtrl5->SetValue(wynik );
}

void Zad2Frame::OnButton4Click(wxCommandEvent& event)
{
    Obliczenia oblicz;
    wxString rzecz1 = TextCtrl1->GetValue();
    wxString uroj1 = TextCtrl2->GetValue();
    wxString rzecz2 = TextCtrl3->GetValue();
    wxString uroj2 = TextCtrl4->GetValue();
    double drzecz1 = atof(rzecz1);
    double duroj1 = atof(uroj1);
    double drzecz2 = atof(rzecz2);
    double duroj2 = atof(uroj2);

    Zespolona rzeczywiste {drzecz1,drzecz2};
    Zespolona urojone {duroj1,duroj2};
    Zespolona liczba_iloraz = oblicz.iloraz(rzeczywiste,urojone);
    wxString wynik;
    wynik.Printf("%.1f %.1fi",  liczba_iloraz.re, liczba_iloraz.im);
    TextCtrl5->SetValue(wynik );
}

Najpierw funkcję Dragon dodalem do klasy Zad2Frame

class Zad2Frame: public wxFrame
{
    public:
        Zad2Frame(wxWindow* parent,wxWindowID id = -1);
        virtual ~Zad2Frame();
       void Dragon();

        //(*Handlers(Zad2Frame)
        void OnQuit(wxCommandEvent& event);
        void OnAbout(wxCommandEvent& event);

Potem odwolalem się do niej i przekleilem kod:

void Zad2Frame::Dragon(){
Obliczenia oblicz;
    wxString rzecz1 = TextCtrl1->GetValue();
    wxString uroj1 = TextCtrl2->GetValue();
    wxString rzecz2 = TextCtrl3->GetValue();
    wxString uroj2 = TextCtrl4->GetValue();
    double drzecz1 = atof(rzecz1);
    double duroj1 = atof(uroj1);
    double drzecz2 = atof(rzecz2);
    double duroj2 = atof(uroj2);
    Zespolona rzeczywiste {drzecz1,drzecz2};
    Zespolona urojone {duroj1,duroj2};
}

void Zad2Frame::OnButton2Click(wxCommandEvent& event)
{
Zad2Frame obiekt;
obiekt.Dragon();
    Zespolona liczba_roznica = oblicz.roznica(rzeczywiste,urojone);
    wxString wynik;
    wynik.Printf("%.1f %.1fi",  liczba_roznica.re, liczba_roznica.im);
    TextCtrl5->SetValue(wynik );
}

Błąd - expect primary expression before "-"

Powód - obiekt.Dragon();

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

double ToDouble(wxTextCtrl *val)
{
	return atof(val->GetValue());
}

Zespolona ToComplex(wxTextCtrl *re,wxTextCtrl *im)
{
	return Zespolona { ToDouble(re), ToDouble(im) };
}

Zespolona Zad2Frame::FirstComplex()
{
	return ToComplex(TextCtrl1,TextCtrl2);
}

Zespolona Zad2Frame::SecondComplex()
{
	return ToComplex(TextCtrl3,TextCtrl4);
}

wxString ToText(const Zespolona &c)
{
	wxString ret;
	ret.Printf("%.1f %.1fi",c.re,c.im);
	return ret;
}

void Zad2Frame::setResult(const Zespolona &c)
{
    TextCtrl5->SetValue(ToText(c));
}

void Zad2Frame::OnButton1Click(wxCommandEvent& event)
{
	setResult(Obliczenia.suma(FirstComplex(),SecondComplex()));
}

class Zad2Frame: public wxFrame
{
    public:
        Zad2Frame(wxWindow* parent,wxWindowID id = -1);
        virtual ~Zad2Frame();
        Zespolona FirstComplex();
        Zespolona SecondComplex();
(...)

Error: Zespolona does not name a type

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

    }

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

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

    static Zespolona iloraz( const Zespolona& a, const Zespolona& b )
    {
        auto b2 = b.re * b.re + b.im * b.im;
        return { (a.re * b.re + a.im * b.im)/b2,  (-a.re * b.im + a.im * b.re)/b2};
    }
};
    double ToDouble(wxTextCtrl *val)
{
    return atof(val->GetValue());
}

Zespolona ToComplex(wxTextCtrl *re,wxTextCtrl *im)
{
    return Zespolona { ToDouble(re), ToDouble(im) };
}

Zespolona Zad2Frame::FirstComplex()
{
    return ToComplex(TextCtrl1,TextCtrl2);
}

Zespolona Zad2Frame::SecondComplex()
{
    return ToComplex(TextCtrl3,TextCtrl4);
}

wxString ToText(const Zespolona &c)
{
    wxString ret;
    ret.Printf("%.1f + %.1fi",c.re,c.im);
    return ret;
}

void Zad2Frame::setResult(const Zespolona &c)
{
    TextCtrl5->SetValue(ToText(c));
}

void Zad2Frame::OnButton1Click(wxCommandEvent& event)
{
    setResult(Obliczenia::suma(FirstComplex(),SecondComplex()));
}

void Zad2Frame::OnButton2Click(wxCommandEvent& event)
{
    setResult(Obliczenia::roznica(FirstComplex(),SecondComplex()));
}

void Zad2Frame::OnButton3Click(wxCommandEvent& event)
{
    setResult(Obliczenia::iloczyn(FirstComplex(),SecondComplex()));
}

void Zad2Frame::OnButton4Click(wxCommandEvent& event)
{
    setResult(Obliczenia::iloraz(FirstComplex(),SecondComplex()));
}

• plik nagłówkowy Struktura.h dołączony do Zad2Main.cpp

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