operator =

Potrzebuje przeciazyc operator = i mam z tym mały kłopot
klasa liczby zespolonej :

using namespace std;

class Zesp
{
public:
  double re, im;
  
  Zesp (double, double);
  void Sprzezenie();
  bool operator != (double);
  bool operator == (double);
  Zesp operator + (Zesp);
  Zesp operator - (Zesp);
  Zesp operator * (Zesp);
  Zesp operator / (Zesp);
  Zesp operator / (double);
  Zesp operator *(float);
  void Zmien(float, float); 
  Zesp ();
};

klasa rozwiazania:

class Rozwiazania
{
   Wektor    rozwiazanie;                           // rozwiazanie w postaci wektora
   Macierz * wspolczynniki;                          // wskaźnik na tablice wspolczynnikow
   Wektor  * wyrazy_wolne;                          // wsk. do wektora wyr. wolnych
   Zesp     blad;                           // blad
   Macierz   Macierz_nowe_kolumny[3];                    // macierz z dolaczonymi kolumnami
   Zesp     Wyznacznik_G;               // głowny wyznacznik macierzy podstawowej
   Zesp     Wyznacznik_K[3];          //wyznacznik macierzy po zamianie kolumn
   
  public:        
   void  Macierz_zamiany (Macierz&,Wektor&);
   void  Wyswietl_rownanie();
   void  Rozwiazanie_rownania();
   float Wynik_bledu();
};

fragment w ktorym potrzebne jest przeciazenie:

float Rozwiazania::Wynik_bledu()
  { 
  Zesp blad;
  Zesp Wektor_bledu;

      
  Wektor_bledu=*wspolczynniki*(rozwiazanie)-*wyrazy_wolne;
}

A jaki dokładnie masz kłopot?

Znalazlem przykladowe przeciazenie takowego operatora dla jakiejs klasy , wyglada ono nastepujaco:

CIntArray& CIntArray::operator=(const CIntArray& aTablica)
{
    // usuwamy naszą tablicę
    delete[] m_pnTablica;

    // alokujemy tyle pamięci, aby pomieścić przypisywaną tablicę
    m_uRozmiar = aTablica.m_uRozmiar;
    m_pnTablica = new int [m_uRozmiar];

    // kopiujemy tablicę
    memcpy (m_pnTablica, aTablica.m_pnTablica, m_uRozmiar * sizeof(int));

    // zwracamy wynik
    return *this;
}

ale nie wydaje mi sie zebym mogl z niego skorzystac, wyglada na dosc skomplikowane a ja po prostu potrzebuje przypisac jedno pole do drugiego

To co znalazłeś jest błędne, na tym się nie wzoruj.

Zesp& operator=(const Zesp& wzor)
{  
  if(&wzor != this) //tutaj jest to zbędny warunek, ale dobrze nabrać taki nawyk zeby nie pisać takich głupot jak w tym kodzie powyżej...
  {
    this->re = wzor.re;
    this->im = wzor.im;
  }
  return *this;
}

dzieki rozumiem że:

this->re = wzor.re;

wartosc pola wzor przypisujemy do wartosci rzeczywistej l. zesp?
this->re tzn ze odwolujemy sie do pola z :

using namespace std;

class Zesp
{
public:
  double <b>re</b>, im;

?

otrzymuje blad przy kompilacji expected primary-expression before '!=' token
nie wiem czego on moze chciec przed tym sylbolem != bo przeciez jest argument z lewej i prawej

class Zesp
{
public:
  double re, im;
  
  Zesp (double, double);
  void Sprzezenie();
  bool operator != (double);
  bool operator == (double);
  Zesp operator + (Zesp);
  Zesp operator - (Zesp);
  Zesp operator * (Zesp);
  Zesp operator / (Zesp);
  Zesp operator / (double);
  Zesp operator *(float);  
  void Zmien(float, float); 
  Zesp & operator = (const Zesp&);
  Zesp ();
};
Zesp & Zesp::operator=(const Zesp& wzor)
{  
  if (&Zesp != this) //tutaj jest to zbędny warunek, ale dobrze nabrać taki nawyk zeby nie pisać takich głupot jak w tym kodzie powyżej...
  {
    this->re = wzor.re;
    this->im = wzor.im;
  }
  return *this;
}

Mea culpa, poprawiłem już w poscie wyżej, chodziło przecież o
&wzor ;)

this->składnik oznacza ze odwołujesz się do pola obiektu na którym teraz pracujesz. Czyli jak wywołujesz np. obiekt.metoda() to odnosisz się do składników tego oboektu. Tak samo obiekt = cośtam to tak na prawdę obiekt.operator=(cośtam)

kompiluje sie to przeciazenie bez problemu ale w klasie rozwiazania w metodzie wynik_bledu to przeciazenie nie dziala a przeciez po to je robilismy wyskakuje komunikat:

495 C:\Users\wasu\Desktop\Uklad_zesp\ukl_rownan_tb.cpp no match for 'operator=' in 'Wektor_bledu = (&operator*(((const Macierz&)((const Macierz*)((Rozwiazania*)this)->Rozwiazania::wspolczynniki)), ((const Wektor&)((const Wektor*)((Wektor*)this)))))->Wektor::operator-(((const Wektor&)((const Wektor*)((Rozwiazania*)this)->Rozwiazania::wyrazy_wolne)))'

Podopisuj const tam gdzie ma być i przemyśl który operator powinien zwracać referencje a który wartość, bo inaczej nie mozesz kaskadowo łączyć sobie działań...

nie wiem czy dobrze rozumiem intencje kompilatora, chodzi dokladnie mu o te przeciazenia:?

Wektor operator * (Macierz A,Wektor w) // iloczyn macierzy i wektora
{
   Wektor wynik;
   int i; //iterator po wierszach
   int j; //iterator po kolumnach
   
   for(i=0;i<3;i++)
   {
     wynik[i]=Zesp();
     for(j=0;j<3;j++) wynik[i]=wynik[i]+A(i,j)*w[j];                                  
   }
   return wynik;
}

Wektor Wektor::operator - (Wektor w1) 
{
  Wektor roznica;
  int i;
  for (i=0;i<3;i++) roznica[i]=(*this)[i]-w1[i]; 
  return roznica;
}

nie moga laczyc sie kaskadowo tzn powinienem rozdzielic te dzialanie?

Nie moge tego wszystkiego zgrac. Program ma rozwiazywac uklad 3 rownan dla liczb zespolonych, oraz liczyc blad ktory wyraza sie wzorem ||Ax-b|| A to macierz wspolczynnikow x wektor rozwiazan a b wektor wyrazow wolnych. W programie na liczbach calkowitych udalo mi sie to zrobic. Program dla l. zespolonych dziala prawidlowo poza liczonym bledem, jesli ktos moglby rzucic okiem na te dwie metody Modul oraz Wynik_bledu, bo ja juz opadam z sil,dziek iwielkie za pomoc, w zalczniku daje wersje programu dla liczb calkowitych oraz l. zespolonych z ktora musze sie uporac
http://www.wrzucaj.com/222926

przeciazamy napisał(a)

nie wiem czy dobrze rozumiem intencje kompilatora, chodzi dokladnie mu o te przeciazenia:?

Wektor operator * (Macierz A,Wektor w) // iloczyn macierzy i wektora

nie moga laczyc sie kaskadowo tzn powinienem rozdzielic te dzialanie?

Nie piszesz jak to zrobiłeś, ale nie możesz mieć tego operatora jako składnika klasy. Operatory będące składnikami klasy domyślnie przyjmują że lewy argument to this, a ewentualny prawy to to co podajesz jako argument w deklaracji. Co najwyżej taki operator może być funkcją zaprzyjaźnioną.