Операции с комплексными числами и перегрузка операторов << и >>

// файл attach.h
class complex
{
private:
    double real;
    double imagine;
public:
    complex (double r, double i);
    complex ();
    friend complex operator+ (const complex &x, const complex &y);
    friend complex operator- (const complex &x, const complex &y);
    friend complex operator* (const complex &x, const complex &y);
    friend complex operator* (double n, const complex &x);
    friend complex operator~ (const complex &x);
    friend std::ostream & operator<< (std::ostream & os, const complex & x);
    friend std::istream & operator>> (std::istream & os, const complex & x);
}

// файл file1.cpp
#include "attach.h"
#include <iostream>
using namespace std;
 
complex :: complex (double r, double i)
{
    real = r;
    imagine = i;
}
 
complex :: complex()
{
    real = imagine = 0.0;
}
 
complex operator+ (const complex &x, const complex &y)
{
        return complex (x.real + y.real, x.imagine + y.imagine);
}
 
complex operator- (const complex &x, const complex &y)
{
        return complex (x.real - y.real, x.imagine - y.imagine);
}
 
complex operator* (const complex &x, const complex &y)
{
        return complex (x.real * y.real - x.imagine * y.imagine, x.real * y.real + x.imagine * y.imagine);
}
 
complex operator* (double n, const complex &x)
{
    return complex (n * x.real, n * x.imagine);
}
 
complex operator~ (const complex &x)
{
    return complex (x.real, -x.imagine);
}
 
ostream & operator<< (ostream &os, const complex &x)
{
    os << x.real << ", " << x.imagine << "i";
    return os;
}
 
istream & operator>>(istream &is, const complex &x)
{
    is >> x.real >> x.imagine;
    return is;
}

// файл main.cpp
#include <iostream>
#include "attach.h"
using namespace std;
int main()
{
    complex a(3.0, 4.0);
    complex c;
    cout << "Enter a complex number (q to quit):\n";
    while (cin >> c)
    {
        cout << "real: ";
        double r;
        cin >> r;
        cout << "imaginary: ";
        double i;
        cin >> i;
        cout << "c is " << c << '\n';
        cout << "complex conjugate is " << ~c << '\n';
        cout << "a is " << a << '\n';
        cout << "a + c is " << a + c << '\n';
        cout << "a - c is " << a - c << '\n';
        cout << "a * c is " << a * c << '\n';
        cout << "2 * c is " << 2 * c << '\n';
        cout << "Enter a complex number (q to quit):\n";
    }
    cout << "Done!\n";
    return 0;
}

#include <iostream>
 
using namespace std;
 
class CDummy
{
private:
    int a, b;
 
public:
    CDummy( int _a = 0, int _b = 0 ) : a(_a), b(_b) {};
    CDummy( const CDummy &d ) : a(d.a), b(d.b) {};
 
    CDummy & operator+=( const CDummy &d )
    {
        a += d.a;
        b += d.b;
        return *this;
    }
    
    //ему не обязательно быть другом класса
    //friend CDummy operator+( const CDummy &d1, const CDummy &d2 );
 
    friend ostream & operator<<( ostream &os, const CDummy &d );
    friend istream & operator>>( istream &is, CDummy &d );
};
 
//-------------------------------------------------------------------------
 
CDummy operator+( const CDummy &d1, const CDummy &d2 )
{
    CDummy ret = d1;
    ret += d2; // использует встроенный operator+=
    return ret;
}
 
ostream & operator<<( ostream &os, const CDummy &d )
{
    os << d.a << "; " << d.b;
    return os;
}
 
// формат: a; b
istream & operator>>( istream &is, CDummy &d )
{
    int a;
 
    is >> a;
 
    char ch;
    cin >> ch;
 
    if( ch != ';' )
    {
        is.setstate( ios::failbit );
        return is;
    }
 
    cin >> d.b;
    d.a = a;
 
    return is;
}
 
//-------------------------------------------------------------------------
 
int main()
{
    CDummy dummy1( 5, 6 );
    CDummy dummy2( 12, 2 );
 
    cout << "1: " << dummy1 << "\n2: " << dummy2 << '\n';
 
    CDummy dummy3 = dummy1 + dummy2;
 
    cout << "3: " << dummy3 << '\n';
 
    cout << "3> ";
 
    cin >> dummy3;
 
    cout << "3: " << dummy3 << "\n2: " << dummy2 << "\n3+2: " << dummy3 + dummy2 << '\n';
 
    return 0;
}