Operatii De +, -, / A Doua Numere Complexe, Folosind Poo

[+skyler_sdf]

se citesc z1 si z2 numere complexe si un numar natural n, se cere sa se scrie un program care calculeaza (z1/z2)^n.

La acest tip de problema vom avea nevoie de supraincarcarea functiilor.

Compilatorul de c++ stie sa lucreze cu +, -, / si * pe numere, insa nu si pentru obiecte.

De aceea trebuie sa defin noi metodele de +, - si / pentru lucrul cu obiecte de tip complex.

O metoda supraincarcata are acelasi nume ca al clasei din care face parte, urmata de "operator +", -, dupa cazuri.

Nu se pot folosi mai mult de un parametru pentru aceasta.

In cazul in care vrem sa folosim doi, functia va trebui declara de tip friend. Acest tip de metode vor fi detaliate in exemplele urmatoare.

#include<iostream>

#include<math.h>

using namespace std;

class complex

{

public: 

	float x, y;

	float modul(); //il folosim pentru a returna modulul

	complex(); // vom initializa pe x si y cu 0

    complex(float a, float b); //il folosim pentru a copia a in x si b in y

	complex operator+(complex k);

	complex operator-(complex k);

	complex operator*(complex k);

	complex operator/(complex k);

};

complex::complex()

{

	x=0;

	y=0;

}

complex::complex(float a, float b) //constructor de copiere

{

	x=a;

	y=b;

}

//pentru adunarea a doua numere complexe folosim formula

// ... =x1+x2 +i(y1+y2)

complex complex::operator+(complex k)

{

	complex h; //ne folosim de un obiect "auxiliar"

	h.x=x+k.y; 

	h.y=y+k.y;

	return h;

}

//pentru scaderea a doua numere complexe folosim formula

// ...=x1-x2+i(y1-y2)

complex complex::operator-(complex k)

{

	complex h;

	h.x=x-k.x;

	h.y=x-k.y;

	return h;

}

//pentru inmultirea a doua numere complexe folosim formula

// ...=x1x2-y1y2+i(x1y2+x2y1)

complex complex::operator*(complex k)

{

	complex h;

	h.x=x*k.x;

	h.y=y*k.y;

	return h;

}

//pentru impartire folosim formula:

// ...=(x1x2+y1y1+i(x2y1-x1y2))/x2^2+x1^2

complex complex::operator/(complex k)

{

 complex h;

 float aux=k.x*k.x+k.y*k.y; //retine x^2+y^2

 if(aux)

 {


	 h.x=(x*k.x+y*k.y)/aux;

	 h.y=(k.x*y-x*k.y)/aux;

 }

 else

	 cout<<"impartire la 0!!";

 return h;

}

float complex::modul()

{

	return sqrt(x*x+y*y);

}

int main()

{

	complex z1, z2, z3, z4(1, 0); //pentru z1, z2, z3 se apeleaza constructorul implicit care va initializa pe x si y pentru fiecare obiect cu 0.

//in cazul lui z4 se apeleaza cel cu 2 parametri

	int n,i;

	cout<<"n=";

	cin>>n;

	cout<<"z1="<<endl;

	cin>>z1.x>>z1.y; //se citesc noi valori pentru x si y, atat in cazul lui z1,

	cout<<"z2="<<endl;

	cin>>z2.x>>z2.y; //cat si in cazul lui z2

	z3=z1/z2; //z3 are x=0 si y=0, acestia se vor primi noi valori in urma operatiei de "/"

	for(i=1; i<=n; i++)

		z4=z4*z3;

	cout<<z4.x<<" "<<z4.y;

	system("PAUSE");

	return 0;

}

//obs: functiile obtinute prin supraincarcarea operatorilor au aceeasi prioritate si asociativitate ca operatorii respectivi

//functiile obtinute prin supaincarcarea operatorilor au aceeasi n-aritate ca si operatorii respecttivi, astfel:

//daca operatorul este unar si functia este unara, deci nu are parametri

//daca operatorul este binar si functia este binara, aceasta inseamna ca are un singur parametru