Kalkulator liczb zespolonych pomoc w dzieleniu

Zrobiłem kalkulator liczb zespolonych. Mam pytanie co do dzielenia. Jak powinienem zmodyfikować funkcje żeby zamiast tej zabawy w main wywołać tylko funkcję podziel i mieć gotowy wynik?

Przez zabawe mam na myśli to, że najpierw wywołuję funkcjęsprzerzenie a potem mnożę osobno licznik i mianownik a na końcu dzielę.

#include <iostream>
#include "kalkulator.h"
using namespace std;



int main()
{
    Zespol l1(3,1);
    Zespol l2(1,-2);
    Zespol tmp;
    //ponizsze operacje wykonuje żeby podzielić l1 przez l2
    tmp.sprzezenie(l2);
    Zespol tmp_2;
    Zespol tmp_2_2;
    tmp_2.pomnoz(l1,tmp);
    tmp_2_2.pomnoz(l2,tmp);
    Zespol tmp_3;
    tmp_3.podziel(tmp_2,tmp_2_2);
    cout<<"Podziel "<<tmp_3.rz<<" "<<tmp_3.ur<<"i";
    return 0;
}

class Zespol
{
public:
    double rz;
    double ur;
    Zespol();
    Zespol(double x, double y);
    void dodaj(Zespol x1, Zespol x2);
    void pomnoz(Zespol x1, Zespol x2);
    void odejmij(Zespol x1, Zespol x2);
    void podziel(Zespol x1, Zespol x2);
    void sprzezenie(Zespol x1);
};

Zespol::Zespol(double x, double y)
{
    rz=x;
    ur=y;

}
Zespol::Zespol()
{
    rz = 0;
    ur = 0;
}
void Zespol::dodaj(Zespol z1, Zespol z2)
{
    rz = z1.rz + z2.rz;
    ur = z1.ur + z2.ur;
}
void Zespol::pomnoz(Zespol z1, Zespol z2)
{
    rz = (z1.rz * z2.rz)-(z1.ur*z2.ur);
    ur = (z1.rz * z2.ur)+(z1.ur*z2.rz);
}
void Zespol::odejmij(Zespol z1, Zespol z2)
{
    rz = z1.rz - z2.rz;
    ur = z1.ur - z2.ur;
}
void Zespol::podziel(Zespol z1, Zespol z2)
{

    rz = (z1.rz)/(z2.rz);
    ur = (z1.ur)/(z2.rz);
}
void Zespol::sprzezenie(Zespol x1)
{
    rz = x1.rz;
    ur = -x1.ur;
}

Użyj przeładownia operatora według poniższego schematu.

template< class T >
class complex
{
    T _rx;
    T _ry;

public:

    complex( T rx = T() , T ry = T() ): _rx{rx} , _ry{ry} {}
    complex operator/( const complex& value )
    {
        T rxx {_rx} , ryy {_ry}; 
        if( value._rx*value._ry != 0)
        {
            rxx = _rx/value._rx;
            ryy = _ry/value._ry;
        }

        return complex<T>{rxx,ryy};
    }

    const T& rx() const& noexcept { return _rx; }
    T&       rx() & noexcept      { return _rx; }
    T&&      rx() && noexcept     { return std::move(_rx); }

    const T& ry() const& noexcept { return _ry; }
    T&       ry() & noexcept      { return _ry; }
    T&&      ry() && noexcept     { return std::move(_ry); }
};

.......
Użycie 

complex<double> a1 {  3.4 , 6.7 };
complex<double> a2 { -1.4 , 0.7 };
complex<double> a3 = a1/a2;

a1 =  complex<double>{5,1}/ complex<double>{1,5};
a2.rx() = complex<double>{1,1}.rx() + complex<double>{-1,-1}.ry();

Teraz tylko zaimplementuj właściwe obliczenia w przypadku dzielenia. Możesz także podobnie dodać operację mnożenia i dodawania
poprzez przeładowanie operator* i operator+

Zrobiłem coś takiego, na razie dla operator+, gdzie tkwi mój błąd? Program nie chce się skompilować.

int main()
{
    Zespol l1(3,1);
    Zespol l2(1,-2);
    Zespol tmp;
    tmp = l1+l2;

    return 0;
}

class Zespol
{
public:
    double rz;
    double ur;
    Zespol();
    Zespol(double x, double y);
    void dodaj(Zespol x1, Zespol x2);
    void pomnoz(Zespol x1, Zespol x2);
    void odejmij(Zespol x1, Zespol x2);
    void podziel(Zespol x1, Zespol x2);
    void sprzezenie(Zespol x1);
    Zespol operator+(Zespol x1, Zespol x2);
};

Zespol operator+(Zespol z1, Zespol z2)
{
    Zespol p;
    p.rz = z1.rz + z2.rz;
    p.ur = z1.ur + z2.ur;
    return p;
}

A przeczytałeś treść błędu?

Chyba powinieneś podać jaki błąd otrzymujesz, co nie?

Masz globalną funkcję operator+ oraz nieprawidłowo zdefiniowaną funkcję składową Zespol::operator+. Powinieneś się zdecydować albo na funkcję globalną (i usunąć deklarację składowej), albo na funkcję składową (poprawić nagłówek, przerobić globalną na składową). Wybrałbym funkcję składową, będzie łatwiej z ukrywaniem implementacji.

Treść błędu to: error: 'Zespol Zespol::operator+(Zespol, Zespol)' must take either zero or one argument

C++ overloading plus operator