#include <iostream>

using namespace std;

ostream& operator<<(ostream&,class complex); // defined later

class complex {
  static int count;
  double re, im;
public:
  complex(double r,double i): re(r),im(i) { count++; cout<<"(double,double)\n";}
  complex(double r): re(r),im(0) { count++; cout<<"(double)\n";}
  complex(const complex &x): re(x.re),im(x.im) { count++; cout<<"(const complex&)\n";}
  complex(): re(0),im(0) { count++; cout<<"()\n";}
  ~complex() { count--; cout<<"~\n";}

  double real() const { return re; }
  void real(double d) { re=d;}
  double imag() const { return im; }
  void imag(double d) { im=d; }

  static int instances() { return count; }

  friend complex operator+(const complex&, const complex&);
  friend complex operator-(const complex&, const complex&);
  friend complex operator*(const complex&, const complex&);
  friend complex operator/(const complex&, const complex&);

  friend complex operator+=(complex&,complex);
  friend complex operator-=(complex&,complex);

  friend complex operator++(complex&);     // prefix
  friend complex operator++(complex&,int); // postfix

  friend int operator==(const complex&,const complex&);
};

int complex::count=0;

complex operator+(const complex &x, const complex &y) {
  return complex(x.re+y.re,x.im+y.im);
  }

complex operator+(const complex &x) {
  return x;
  }

complex operator-(const complex &x) { return complex(-x.real(),-x.imag()); }

complex operator-(const complex &x, const complex &y) {
  return complex(x.re-y.re,x.im-y.im);
  }

complex operator*(const complex &x, const complex &y) {
  return complex(x.re*y.re-x.im*y.im,
                 x.re*y.im+y.re*x.im);
  }

complex operator/(const complex &x, const complex &y) {
  double denom=1.0/(y.re*y.re+y.im*y.im);
  return x*complex(y.re,-y.im)*denom;
  }

complex operator+=(complex &x,complex y) { x.re+=y.re; x.im+=y.im; return x; }

complex operator-=(complex &x,complex y) { x.re-=y.re; x.im-=y.im; return x; }

complex operator++(complex &x) { return x+=complex(1); }  // prefix

complex operator++(complex &x,int) {  // postfix
  complex save(x);
  x+=complex(1);
  return save;
  }

int operator==(const complex &x,const complex &y) {
  return x.re==y.re && x.im==y.im;
  }

int operator!=(const complex &x,const complex &y) { return !(x==y); }

complex operator*=(complex &x,complex z) {
  complex save(x);
  x.real(save.real()*z.real()-save.imag()*z.imag());
  x.imag(save.imag()*z.real()+save.real()*z.imag());
  return x;
  }

complex operator/=(complex& x,complex z) {
  complex numer=x*complex(z.real(),-z.imag());
  double denom=1.0/(z.real()*z.real()+z.imag()*z.imag());
  x=complex(numer.real()*denom,numer.imag()*denom);
  return x;
  }

ostream& operator<<(ostream &x,complex y) { x<<y.real()<<' '<<y.imag(); return x; }

istream& operator>>(istream &x,complex &y) {
  double re,im;

  x>>re>>im;
  y.real(re);
  y.imag(im);
  return x;
  }

int main() {
  complex x(1,2),y(3,4);
  x+=y;
  cout<<x<<endl;
  cin>>x>>y;
  x=x+y;
  cout<<x<<endl;

  cout<<++x<<endl;
  x=complex(10,20);
  cout<<++x<<endl;
  cout<<x++<<endl;
  cout<<x++<<endl;

  cout<<complex(11,22)+complex(33,44)<<endl;
  cout<<complex(10,5)*complex(2,1)<<endl;
  cout<<+complex(111,222)<<endl;
  cout<<-complex(111,222)<<endl;
  cout<<(complex(111,222)==complex(111,222))<<endl;
  cout<<(complex(111,222)!=complex(111,222))<<endl;
  x=complex(10,20);
  cout<<(x+=complex(3,4))<<endl;
  cout<<complex(1,1)/complex(0,0)<<endl;
  cout<<"Instances: "<<complex::instances()<<endl;
  }