TD5

Créer un projet dans lequel vous définissez une classe de nombre complexe qui aura typiquement la structure suivante :

#ifndef complexHPP
#define complexHPP
 
class Complex
{
private:
	double mRealPart;
	double mImaginaryPart;
public:
	Complex();
	~Complex();
...
};
 
#endif

Ajouter à cette classe un ou plusieurs opérateurs de conversion convertissant un nombre flottant en un nombre complexe.

class Complex
{
private:
... 
public:
    Complex(double aReal) : mRealPart(aReal), mImaginaryPart(0.0) {}
    Complex(float aReal) : mRealPart(aReal), mImaginaryPart(0.0) {}
... 
};

class Complex
{
private:
... 
public:
    Complex(double aReal) : mRealPart(aReal), mImaginaryPart(0.0) {}
    Complex(float aReal) : mRealPart(aReal), mImaginaryPart(0.0) {}
    Complex(int aReal) : mRealPart((double)aReal), mImaginaryPart(0.0) {}
    Complex(unsigned in aReal) : mRealPart((double)aReal), mImaginaryPart(0.0) {}
... 
};

Ajouter à cette classe une fonction qui affiche le nombre complexe sur la console.

Créer deux fonctions statiques créant des nombre complexes, l’une créant un nombre complexe à partir d’une paire correspondant à la partie réelle et imaginaire, l’autre créant un nombre complexe à partir de la paire (ρ,θ) correspondant à la notation polaire de ce nombre.

Créer une variable globale ayant comme type la classe complexe et ayant pour valeur la valeur imaginaire 1.

Tester le bon comportement de votre classe sur des exemples simples. Notamment, est-il possible d’écrire désormais :

    Complex complexValue = 3.3 + 5 * I;

Nous considérons les opérations de base simple que sont l’addition et la soustraction.

Proposer une surcharge des opérations + et –. Implanter ces dernières et tester.

	Complex operator + (const Complex& aRightValue) const;
	Complex operator - (const Complex& aRightValue) const;

Proposer une surcharge des opérations + et –. Implanter ces dernières et tester.

	Complex operator + (double aLeftValue, const Complex& aRightValue);
	Complex operator – (double a aLeftValue, const Complex& aRightValue);

Expliquer la différence avec les opérations précédentes ?

Tester le bon comportement de votre classe sur des exemples simples. Notamment, est-il possible d’écrire désormais :

	Complex complexValue = 3.3 + 5 * I;

Proposer une surcharge des opérations += et –=. Implanter ces dernières et tester.

	Complex& operator += (const Complex& aRightValue);
	Complex& operator -= (const Complex& aRightValue);

Expliquer pourquoi les signatures des operations += et -= sont différentes de celles des operations + et - ?

Nous considérons les opérations de base que sont la multiplication et la division.

Proposer deux fonctions de conversion entre la représentation polaire et la représentation canonique des nombres complexes et implanter les.

Proposer une surcharge des opérations + et –. Implanter ces dernières et tester.

	Complex operator * (const Complex& aRightValue) const;
	Complex operator / (const Complex& aRightValue) const;

Proposer une surcharge des opérations + et –. Implanter ces dernières et tester.

    Complex& operator *= (const Complex& aRightValue);
    Complex& operator /= (const Complex& aRightValue);