Класс комплексных чисел

#include <iostream.h>
#include <math.h>
class Complex{
   private:
        double Re;
        double Im;
 
   public:
        Complex(void) {
                Re=Im=0.0;
        }
 
        Complex(double re){
                Re=re;
                Im=0.0;
        }
 
        Complex(double re, double im){
                Re=re;
                Im=im;
        }
 
        Complex(Complex& c){
                Re=c.Re;
                Im=c.Im;
        }
 
        ~Complex(void) {}
 
        double abs(){
                return sqrt(Re*Re+Im*Im);
        }
 
        double argDeg(){
                if ((Re==0.0)&&(Im==0.0)) return 0.0;
                if (Re==0.0){
                        if (Im>0) return 90.0; else return -90.0;}
                else
                        if (Re>0.0) return atan(Im/Re)*180/M_PI;
                else
                        {if (Im>=0) return 180+atan(Im/Re)*180/M_PI;
                        else return -180+atan(Im/Re)*180/M_PI;}
 
        }
 
        double argRad(){
                if ((Re==0.0)&&(Im==0.0)) return 0.0;
                if (Re==0.0){
                        if (Im>0) return M_PI/2; else return -M_PI/2;}
                else
                        if (Re>0.0) return atan(Im/Re);
                else
                        {if (Im>=0) return M_PI+atan(Im/Re);
                        else return -M_PI+atan(Im/Re);}
        }
 
 
 
        Complex& pow(int n){
                static Complex temp;
                temp.Re=(std::pow(abs(),n))*(std::cos(n*argRad()));
                temp.Im=(std::pow(abs(),n))*(std::sin(n*argRad()));
                return temp;
        }
 
 
        Complex& radikal(int n, int k){
                static Complex temp;
                if ((Re==0)&&(Im==0)) return temp;
                temp.Re=std::pow(abs(),1/n)*cos((argRad()+2*M_PI*(k))/n);
                temp.Im=std::pow(abs(),1/n)*sin((argRad()+2*M_PI*(k))/n);
                return temp;
        }
 
        Complex& conjugate(){
                Im=-Im;
                return *this;
        }
 
        Complex& operator - (){
                static Complex temp(-Re, -Im);
                return temp;
        }
 
        Complex& operator + (){
                static Complex temp(Re, Im);
                return temp;
        }
 
        Complex& operator = (Complex& c) {
                Re=c.Re;
                Im=c.Im;
                return *this;
        }
 
 
 
        friend bool operator == (const Complex& c1, const Complex& c2){
                if ((c1.Re==c2.Re)&&(c1.Im==c2.Im)) return true;
                else return false;
        }
 
        friend bool operator != (const Complex& c1, const Complex& c2){
                if ((c1.Re!=c2.Re)||(c1.Im!=c2.Im)) return true;
                else return false;
        }
 
        friend Complex& operator + (Complex& left, Complex& right){
                static Complex tempAdd;
                tempAdd.Re=left.Re+right.Re;
                tempAdd.Im=left.Im+right.Im;
                return tempAdd;
        }
 
        Complex& operator +=(Complex& c){
                return *this=*this+c;
        }
 
        friend Complex& operator - (Complex& left, Complex& right){
                static Complex tempSub;
                tempSub.Re=left.Re-right.Re;
                tempSub.Im=left.Im-right.Im;
                return tempSub;
        }
 
        Complex& operator -=(Complex& c){
                return *this=*this-c;
        }
 
        friend Complex& operator * (Complex& left, Complex& right){
                static Complex tempMult;
                tempMult.Re=left.Re*right.Re-left.Im*right.Im;
                tempMult.Im=left.Im*right.Re+left.Re*right.Im;
                return tempMult;
        }
 
        Complex& operator *=(Complex& c){
                return *this=*this * c;
        }
 
        friend Complex& operator / (Complex& left, Complex& right){
                static Complex tempDiv;
                tempDiv.Re=(left.Re*right.Re+left.Im*right.Im)/(left.Im*left.Im+right.Im*right.Im);
                tempDiv.Im=(left.Im*right.Re-left.Re*right.Im)/(left.Im*left.Im+right.Im*right.Im);
                return tempDiv;
        }
 
        Complex& operator /=(Complex& c){
                return *this=*this / c;
        }
 
        friend ostream& operator<<(ostream& s, Complex& c){
                if (c.Im>0.0) s<<c.Re<<"+"<<c.Im<<"i";
                else if (c.Im==0.0) s<<c.Re;
                else s<<c.Re<<c.Im<<"i";
                return s;
        }
 
        friend istream& operator>>(istream& s, Complex& c){
                s>>c.Re;
                s>>c.Im;
                return s;
        }
 
        Complex& log(){
                static Complex temp,t1,t2(0,1);
                temp.Re=std::log(abs());
                t1.Re=argRad();
                t1.Im=0;
                t1*=t2;
                temp.Re+=t1.Re;
                temp.Im+=t1.Im;
                return temp;
        }
 
        Complex& pow(Complex& n, int k){
                static Complex temp,t1,t2;
                t1=log();
                t1.Im+=2*M_PI*k;
                t2=n*t1;
                temp.Re=std::exp(t2.Re)*std::cos(t2.Im);
                temp.Im=std::exp(t2.Re)*std::sin(t2.Im);
                return temp;
        }
 
 
 
};