klasa do obsługi liczb zespolonych a przeładowanie operatorów

//przeladowany operator +
Zesp operator +( Zesp z ) {
    Zesp roboczy;
    roboczy.re =( * this ).re + z.re;
    roboczy.im =( * this ).im + z.im;
    return roboczy;
}

// przeladowany operator =+
Zesp & operator +=( Zesp z ) {
    ( * this ) =( * this ) + z;
    return( * this );
}

// przeladowany operator <<
ostream & operator <<( ostream & wypis, Zesp & z ) {
    wypis << z.re << " + " << z.im << "i";
    return wypis;
}

cout << z1 + z2;

#include <iostream>
using namespace std;
class Zesp {
    int re;
    int im;
    friend ostream & operator <<( ostream & wypis, Zesp && z );
public:
    Zesp( int _re, int _im )
        : re( _re )
         , im( _im )
    {
       
    }
    Zesp operator +( Zesp z ) {
        Zesp roboczy( 0, 0 );
        roboczy.re =( * this ).re + z.re;
        roboczy.im =( * this ).im + z.im;
        return roboczy;
    }
   
    // przeladowany operator =+
    Zesp & operator +=( Zesp z ) {
        ( * this ) =( * this ) + z;
        return( * this );
    }
   
    // przeladowany operator <<
   
};

ostream & operator <<( ostream & wypis, Zesp && z ) {
    wypis << z.re << " + " << z.im << "i";
    return wypis;
}

int main() {
    Zesp z1( 2, 2 );
    Zesp z2( 4, 5 );
    cout << z1 + z2 << endl;
}

#include <iostream>
using namespace std;
/////////////////////////////////////////////////////////////////////
class Zesp {
    double re;
    double im;
public:
    // deklaracja przyjaźni z funkcją operator <<
    friend ostream & operator <<( ostream & ekran, Zesp & z );
   
    // konstruktor (domniemany, bo bez argumentow)
    Zesp( double x = 0, double y = 0 )
        : re( x )
         , im( y )
    { /*pusty konstrktor*/ }
   
    //przeladowany operator +
    Zesp operator +( Zesp z ) {
        Zesp roboczy;
        roboczy.re =( * this ).re + z.re;
        roboczy.im =( * this ).im + z.im;
        return roboczy;
    }
   
    // przeladowany operator =+
    Zesp & operator +=( Zesp z ) {
        ( * this ) =( * this ) + z;
        return( * this );
    }
   
   
};
// przeladowany operator <<
ostream & operator <<( ostream & wypis, Zesp & z ) {
    wypis << z.re << " + " << z.im << "i";
    return wypis;
}
/////////////////////////////////////////////////////////////////////
int main() {
    Zesp z1( 3, 4 );
    Zesp z2( 4, 3 );
    Zesp z3( 1, 5 );
    z3 = z1 + z2;
    operator <<( cout, z1 );
}

class Test
{
private:
   
    int a, b;
   
public:
   
    Test()
        : a( 1 )
         , b( 100 )
    { }
   
    Test & operator +=( const Test & t )
    {
        a += t.a;
        b += t.b;
       
        return * this;
    }
   
    Test operator +( const Test & t )
    {
        Test ret( * this );
       
        ret += t;
       
        return ret;
    }
};