cours

 %20/04/2019%
la notaion infixée 		-> a+b;
la notaion postfixée 	-> ab+;
la notaion prefixée 	-> +ab;

	une expression arethmetique ou logique est formée de operateur et d'operande en pratique en utilise la notaion infxée ou
parfois la notaion prefixée et postfixée ces 3 type de notation sont equivalant a une notaion fonctionelle qui est deduite
des 3 type de notaion en utilisent une structure informatique a dequat qui est l'arbre expression.

	en C++ le compilateur se charge de transformer une expression ecrite de maniere infixée en une serie d'appele de fonction
mais cette approche demande que l'on fournisse le code des differantes fonctions qui seront appeler par le compilateur pour
evaluer l'expression.

	Les Regles :
	|->	on ne peut surcharger un operateur si il a au-moins de ces un operande "Objet".
	|->	on garder la pluralite en d'autre terme "binaire" "unaire" "ternaire".
	|->	on peut surcharger JUST LES OPERATEUR existant du C plus "new" et "delete".
	|->	on garde la priorite et l'associativite des operateurs meme apres surcharge.

	Exemple :
	class Int
	{
		private:
			int val;
		public:
			Int(int = 0);
			friend const Int operator+ (const Int &, const Int &);
			friend const Int operator- (const Int &) const;
	};

 %29/04/2019%
CDU -> Conversion definis par Utilisateur
	les Regles CDU
1 -- Implementer sous forme de methode (Class d'implementation);
  |-> 2 cas :
		1 -- la class cible:
		  |-> on utlise Constructeur pouvant etre appele avec 1 arg de type source;
		2 -- la class source:
		  |-> dans ce cas on definit une methode pour convertire les obj de la class cible en class source


2 -- il ne doit y avoir QU'UNE SEUL CDU par conversion;
3 -- il ne doit y avoir qu'une seul chaine de conversion possible;
4 -- a l'aide du mot cle "explicit" on interdit tous conversion implicite

REMARQUE :
	- Les CDU creent un obj TEMP cible qui est considere par LE C++ Comme etant CONST
	et donc toutes fn ou operateur utlisant un passsage par valeur ou passage par ref CONST est valide pour la Conversion
	par contre l'utilisation du ref NON-CONST est INTERDITE

Derivation et Composition -> Reutilisabilite du code en poo ou "Code re-use" en anglais c'est a dire utliser des classe existante pour creer des nouvelles

1 -- Composition:
	|-> Composition faible
	|-> Composition Forte (Aggregation)

	l'objet de class comporte des sous-obj d'autres classes
	Exemple :
		class point{
			float x,y;
			public:
				point(float =0 ,float =0);
				void rotateX (float);
				void rotateY (float);
		};

		class circle{
				float mr;
				point centre;
			public:

				cercle(float r,float x,float y)
					:mr(r), centre(x,y)
				{}

				cercle(float r,const point &p)
					:mr(r),centre(p)
				{}

				cercle(const cercle &rc)
					:mr(rc.mr),centre(rc.centre)
				{}

				~cercle(){
					appele auto des desructeur pour chaque sous obj;
				}
		};

	-- le constructeur de l'objet Compose doit rappeler un constructeur pour chaqun des sous obj
	-- RECHERCHE LES APPELS DES CONSTRUCTEUR DANS UNE ZONE APPELE LISTE D'INITIALISATION
	-- ou cas ou le constructeur manque le compilateur en synthetise un implicitement pour le sous obj qu'on peut apple sans args ! EN GROS IL SE DEBROUILLE !
	-- dans le destructeur d'un obj comp le compilateur appel auto les destructeur de chaque ss obj

	REMARQUE :
		pour les obj composer , la liste d'initialisation des constructeurs peut comporter 4 cas de figure:
		1 - appele d'un constructeur normal pour les sous obj a linterieur d un obj composer normal
		2 - appele d'un constructeur de copie a l interieur de normal
		3 -  							copie					copie
		4 - 							normal 					copie

		dans le cas ou on ne fournie pas de constructeur de copie pour obj comp,le compilateur synthetisera un constructeur de copie lui meme
		se basent sur lappele d'un constructeur de copie pour chaque sous obj

		* - l'ordre suivi par le compilateur pour appeller les differant constructeur dans la liste d'initialisation depans
		uniquement de l'ordre de definission des differant ss obj dans la class

	Exemple:

	class point{
		private:
			float x,y;
		public:
			point(float =0, float =0);
			void rotate(float);
			void translate(float,float);
	};

	class circle{
		private:
			float r;
			point centre;
		public:
			circle(float rr= 0, float xx=0, float yy=0)
			:r(rr),centre(xx,yy)
			{}

			circle(float rr= 0,const point &cc)
			:r(rr), centre(cc)
			{}

			void rotate(float);
			void translate(float,float);
	};

Attention :
		-> Pour un lecture seule(pas de modif) en privilegie :
			- le passage par valeur et le retour par valeur pour les type simple (int,float,double,...etc)
			- le passage par referance donnee constante et le retour par referance sur donnee constante pour les Objets