Problem z liczbami zespolonymi

siema.
mam zadanie:

Przyklad uzycia struktury liczb zespolonych. Program w wersji minimum musi używać struktury opisującej liczby zespolone a+jb i zawierać funkcje dodawania/odejmowania, mnożenia liczb zespolonych i konwersji na postać biegunową.

i nie wiem co dalej robić, czyli mnożenie i konwersja na zespolone, dodam, że kod napisałem, ale nie do końca rozumiem.

#include <iostream>
using namespace std;

class zespolona
{
public:
double re;
double im;
zespolona operator +(const zespolona & prawy); //nie wiem o co tu chodzi (kod z tablicy po prostu)
};

int main()
{
zespolona z1,z2,z3;
z1.re=1;
z1.im=0;
z2.re=7;
z2.im=2;
z3=z1+z2; // wiem że to nie będzie działało w ten sposób

cout<<z3.re<<" "<<z3.im;
return 0;
}

zespolona zespolona::operator+(const zespolona & prawy)
{
zespolona tmp;
tmp.re=this->re+prawy.re;
tmp.im=im+prawy.im;
return tmp;
}

1. Ma sens dodać konstruktor, wtedy operator + można przepisać:
   zespolona zespolona::operator+(const zespolona & prawy)const { return zespolona(re+prawy.re,im+prawy.im); }
2. Warto dodać przeciążenie nawiasów okrągłych aby zamiast: z1.re=1; z1.im=0; pisać: z1(1,0);
3. Warto przeciążyć operator przesunięcia bitowego strumienia aby zamiast: cout<<z3.re<<" ii"<<z3.im; pisać: cout<<z3;

braki brakami, ale się dopiero uczę obiektowego, tylko że laboratoria sobie a na wykładzie tego jeszcze nie było, tak samo z mnożeniem zrobić?

zespolona operator *(const zespolona & prawy);//do class
zespolona zespolona::operator*(const zespolona & prawy)
{
zespolona tmp2;
tmp2.re=this->re*prawy.re;
tmp2.im=im*prawy.im;
return tmp2;
} 

bo jak już pisałem, przeciążania operatorów nie znam jeszcze

Tak, tylko jest inny wzór na mnożenie liczb zespolonych, sprawdź go sobie.

Warto dodać przeciążenie nawiasów okrągłych aby zamiast: z1.re=1; z1.im=0; pisać: z1(1,0);

Ja bym to nazwał dwuargumentowym konstruktorem, a nie jakimś „przeciążeniem nawiasów okrągłych”.

Azarien napisał(a)

Warto dodać przeciążenie nawiasów okrągłych aby zamiast: z1.re=1; z1.im=0; pisać: z1(1,0);

Ja bym to nazwał dwuargumentowym konstruktorem, a nie jakimś „przeciążeniem nawiasów okrągłych”.

A potrafisz zrozumieć różnicę pomiędzy:
zespolona z1(1,0); // konstruktor
a:
z1(1,0); // przeciążone nawiasy okrągłe

A potrafisz zrozumieć różnicę pomiędzy:
Zrozumieć potrafię, lecz niekoniecznie znam każdy niuans C++.
Osobiście nie widzę potrzeby przeciążania tu nawiasów, nawet jeśli jest taka możliwość, jeśli to co chcemy to właśnie konstrukcja obiektu.

Nie konstrukcja, zaś zmiana składowych istniejącego już obiektu.
owszem zawsze po:
zespolona z(1,0);
można napisać:
z=zespolona(0,1);
ale wg mnie prostszy i bardziej elegantsi jest zapis:
z(0,1);
zaś to da się osiągnąć jedynie przeciążając nawiasy okrągłe.

jest tu jeszcze ktoś, kto mógłby mi pomóc?

zespolona operator *(const zespolona & prawy);//do class
zespolona zespolona::operator*(const zespolona & prawy)
{
zespolona tmp2;
tmp2=((this->re*prawy.re) - (im*prawy.im) + (re*prawy.im) + (im*prawy.re));
return tmp2;
} 

nie do końca to rozumiem co już pisałem, ale program chcę najpierw napisać, a potem zrozumieć, bo mam dedline.
i co z konwersją na postać biegunową?

#include <iostream>
using namespace std;
 
class zespolona
{
  public:
    double re;
    double im;
    zespolona operator +(const zespolona &prawy) const;
    zespolona operator *(const zespolona &prawy) const;
    zespolona(double are, double aim);
    friend ostream& operator <<(ostream &out, const zespolona &z);
};
 
 
zespolona::zespolona(double are, double aim)
                     : re(are),
                       im(aim) {}
 
zespolona zespolona::operator +(const zespolona &prawy) const
{
    return zespolona(re+prawy.re, im+prawy.im);
}
 
zespolona zespolona::operator *(const zespolona &prawy) const
{
    return zespolona(re*prawy.re-im*prawy.im, re*prawy.im+im*prawy.re);
}
 
ostream& operator <<(ostream &out, const zespolona &z)
{
    out<<z.re;
    if (z.im != 0)
    {
        if (z.im > 0)
            out<<"+";
        out<<z.im<<"i";
    }
    return out;
}
 
 
int main()
{
  zespolona z1(2,3),
            z2(3,-3);
  cout << z1+z2 << endl;
}

Wyżej napisany program muszę przepisać z zastosowaniem klas. Metody które klasa musi zawierać to:

1. dodawanie(),
2. mnożenie(),
3. to_biegun() - metoda zamieniająca na postać biegunową.

Od czego zacząć i dlaczego?

Ekmh... Czy tam nie masz klas? Czy nie wystarczy to_biegun?

program miał być pierwotnie napisany w języku C, a nie C++, więc polecenie jest (tak mi się wydaje) żeby umieścić klasy w C, czyli przerobić to na C++, ale problem się rozwiązuje, bo w tak został napisany...? -nawet nie wiem czy to jest pytanie.

co to jest właściwie ten friend?

  friend ostream& operator <<(ostream &out, const zespolona &z);

Poczytaj może jakiś pierwszy lepszy z googla kurs C++.
Uprości ci to przynajmniej zadawanie pytań.

jak mam te metody zapisać?

• zamienić na dodawanie? tak samo z mnożeniem?
  bo z biegunem to nie mam logicznego pojęcia jak to zmienić.

Może poczytaj jakiś pierwszy lepszy kurs C++ z googla, za ciebie nikt tu całości nie zrobi.