class Zespolona
{private:
    double re , im;
 public:
    Zespolona(double RE = 0, double IM = 0)
    {
        re = RE;
        im = IM;
    }
	 
    void print()
    {
        if(im>=0)
            cout<<re<<"+"<<im<<"*i"<<endl;
        else
            cout<<re<<im<<"*i"<<endl;
    }
 //OPERACJE:
    bool operator == (const Zespolona &z)
    {
    	if ((re==z.re)&&(im==z.im))return true;
		else return false;
    }
    Zespolona operator= (const Zespolona &z )
	{
	re = z.re; // Lub setRe( z.getRe() ); (jakby były zrobione akcesory)
	im = z.im; // Lub setIm( z.getIm() );
	}
	Zespolona operator* (int x)
	{
        return Zespolona(re*x,im*x);
    } 
	Zespolona operator* (const Zespolona &z)
    {
        return Zespolona(re*z.re-im*z.im,re*z.im+im*z.re);
    } 
    Zespolona operator+ (const Zespolona &z)
    {
        return Zespolona(re+z.re, im+z.im);
    }
    Zespolona operator- (const Zespolona &z)
    {
        return Zespolona(re-z.re , im-z.im);
    } 
    Zespolona operator/ (const Zespolona &z)
    {
        Zespolona wyn;
        double x = z.re * z.re + z.im * z.im;
        if (x>0)
        {
             wyn.re = (re * z.re + im * z.im)/x;
             wyn.im = (z.re * im - re * z.im)/x;
             return wyn;
        }
        else{cout<<"Nie dziel przez 0!";}
    }
    Zespolona operator+ (const int liczbar)
    {
        return Zespolona(re+liczbar,im);
    }
    friend istream& operator>>(istream& is, Zespolona &z)
	{
	    is>>z.re>>z.im;
	    return is;
	}
    friend ostream& operator<<(ostream& os, Zespolona &z)
    {
        if      (z.im == 0) {os<<z.re;}
        else if (z.re == 0) {os<<z.im<<"*i";}
        else if (z.im < 0) {os<<z.re<<z.im<<"*i";}
        else    {os<<z.re<<"+"<<z.im<<"*i";} 
        return os;
    }
    
    int dlugosc()
	{
	ostringstream os;
	os << *this;
	return os.str().size();
	}
	
};
 
 
class macierz :Zespolona
{private:
    int w;
    int k;
 public:   
    Zespolona **tab;
    macierz(); // konstruktor domyślny
    macierz(const macierz& m) // konstruktor kopiujący
	{
	k = m.k+1; 
    w = m.w+1; 
    tab = new Zespolona *[w]; 
    for (int i = 0; i < w; i ++ ) 
    	{
        tab[i] = new Zespolona[k]; 
		}
    for (int i = 0; i < w; i ++ )
	 	{
        for (int j = 0; j < k; j ++ )
			{
            tab[i][j] = m.tab[i][j];
			}
  	 	}
	} 
    macierz(int wiersze, int kolumny) // konstruktor dwuparametrowy
    {
        w = wiersze+1;
        k = kolumny+1;
        tab = new Zespolona* [w];
        for(int i=0 ; i<w ; i++)
        {
            tab[i] = new Zespolona[k];
        }
 
        for(int i=0 ; i<w ; i++)
        {
            for(int j=0 ; j<k ; j++)
            {
                tab[i][j] = 0;
            }
        }
    }
 
    ~macierz()
    {	
        //cout<<endl<<"Zwalnianie pamieci."<<endl;
         for( int i = 0; i < w; i++ )                
	      {delete[]tab[i];}        
	      delete[] tab;
    }
 
    void jednostkowa()
    {
        if (w != k) cout<<"Macierz jednostkowa istnieje tylko dla macierzy kwadratowej !"<<endl;
        else
        {
             for(int i=0; i<w ; i++)
            {
                for(int j=0 ; j<k ; j++)
                {
                   if(i==j) tab[i][j] = 1;
 
                }
            }
        }
 
    }
 
    void zamien(int wiersz,int kolumna, Zespolona z)
    {   int exist_kolumna = 0;
        int exist_wiersz = 0;
        for(int i=0 ; i<w ; i++)
        {
            if(wiersz == i) exist_wiersz = 1;
        }
        for(int i=0 ; i<k ; i++)
        {
            if(kolumna == i) exist_kolumna =1;
        }
        if(exist_kolumna==1 && exist_wiersz==1)
        {
            tab[wiersz][kolumna] = z;
        }
        else cout<<endl<<"W tej macierzy nie ma takiej komorki: ["<<wiersz<<"]["<<kolumna<<"] !"<<endl;
 
    }
 
    macierz operator+ (const macierz &m)
    {   macierz suma(w-1,k-1);
 
        if(w!=m.w || k!=m.k) cout<<"Mozna dodawac tylko macierze o takiej samej liczbie wierszy i kolumn."<<endl;
        else
        {
            for(int i=0 ; i<w ; i++)
            {
                for(int j=0 ; j<k ; j++)
                {
                   suma.tab[i][j] = tab[i][j] + m.tab[i][j];
                }
            }
        }
        return suma;
    }
/*
    macierz operator* (int x)
    {  
        macierz iloczyn(w-1,k-1);
 
        for(int i=0 ; i<w ; i++)
        {
            for(int j=0 ; j<k ; j++)
            {
                iloczyn.tab[i][j] = x * tab[i][j];
            }
        }
        return iloczyn;
    }
*/	
/*
	macierz operator* (int x)
	{	
		macierz iloczyn(w-1,k-1);
		
		for(int i=0 ; i<w ; i++)
        {
            for(int j=0 ; j<k ; j++)
            {
                iloczyn.tab[i][j] = tab[i][j] * x;
        	}
    	}
		return iloczyn;
	}
*/	
	friend macierz operator* (int x,const macierz& m)
	{	
		macierz iloczyn(m.w,m.k);
		Zespolona**tab = m.tab;
		for(int i=0 ; i<m.w ; i++)
        {
            for(int j=0 ; j<m.k ; j++)
            {
                iloczyn.zamien(i+1,j+1,tab[i][j]*x);
        	}
    	}
		return iloczyn;
	}
	
	 void operator= (const macierz &m)
    {
        tab=m.tab;
    }
    
/*	
    macierz operator= (const macierz &m)
    {
        macierz porownanie(w,k);
 
        for(int i=0 ; i<w ; i++)
        {
            for(int j=0 ; j<k ; j++)
            {
                porownanie.tab[i][j] = m.tab[i][j];
            }
        }
        return porownanie;
    }
*/   	
	friend ostream& operator << (ostream& os,const macierz & m)
	{
		os << "dim: "<<m.w<<","<<m.k;
		os << endl;
		os << (char)218;
		int *maxL =new int[m.k];
		for (int j=0;j<m.k;j++)
		{
		maxL[j]=0;
		for (int i=0;i<m.w;i++)
			{
			if (maxL[j]<m.tab[i][j].dlugosc())maxL[j]=m.tab[i][j].dlugosc();
			}
		}
		//drukuj:
		for (int j=0;j<m.k;j++)
			{
			for (int i=0;i<maxL[j];i++) os << " ";
			if (j!=m.k-1) os <<" ";
			}
		os << (char)191<<endl;
		for (int i=0;i<m.w;i++)
			{
			os << (char)179;
			for (int j=0;j<m.k;j++)
				{
				for (int z=0; z<maxL[j]- m.tab[i][j].dlugosc();z++)os << " ";
				os << m.tab[i][j];
				if (j<m.k-1) os << " ";
				}
			os << (char)179<<endl;
			}
		os << (char)192;
		for (int j=0;j<m.k;j++)
		{
		for (int i=0;i<maxL[j];i++) os << " ";
		if (j!=m.k-1) os <<" ";
		}os << (char)217<<endl;
	}

};

int main(){

macierz A(2,2) ,B(2,2),C=A;
A.jednostkowa();
cout << A << endl << C; //pierwszy test czy A!=C
Zespolona u(4,3);
B.zamien(1,1,u);
C=A;
A=6*A;
cout << A << endl << C; //drugi test czy A!=C
C=A+B;
cout << C;

return 0;
}