------------------------------------------------------------------------------
*3*************************** C++ (partie 2) *********************************
---------------------------------| Lefty |------------------------------------

INITIATION AUX CLASSES 
 De meme qu'il existe des types int, float,... on peut definir soi-meme  
 des types. Ces types comprendront des variables et des fonctions qui  
 leur seront associees. Les classes se presentent sous cette forme :  
 class nom 
 {public : fonction1(); 
 fonction 2(); 
 fonction n(); 
 private : variable 1;} 
 tout ce qui est public pourra etre accessible depuis n'importe quelle  
 fonction du programme. Ce qui est private ou protected (on ne va pas  
 entrer dans la nuance). n'est accessible que depuis les fonctions de la  
 classe. On peut acceder a ce genre de variable seulement par  
 l'intermediaire des fonctions public. Bon, un exemple tout de suite : 
 #include"iostream.h" 
 
 class ordi 
 {public : 
 void gprix(a){prix=a;} 
 float aprix(){return prix;} 
 private : 
 float prix;} 
 
 main() 
 {ordi pc; 
 pc.gprix(5000); 
 cout<<"un pc vaut : "<return 0;}  
 
 "vas-y pour les explications ! 
 -OK !" 
 On a declarer une classe ordi comprenant deux fonctions : 
 -gprix qui recoit a comme parametre. La variable prix prends la valeur  
 de a 
 -aprix qui retourne la valeur de prix 
 Puis dans la fonction principale (main je rappelle), on declare un ordi  
 appele pc. On initialise sa valeur a 5000 an passant par la fonction  
 gprix, puis on affiche sa valeur par la fonction aprix. Remarque : on  
 accede aux fonctions d'une classe de cette facon : 
 nom.fonction(parametres) 
 (Si on avait declarer la classe *pc, pc serait un pointeur et il  
 faudrait remplacer . par ->) 
 
 Un peu plus loin :  
 On peut definir une fonction declarer dans la classe en-dehors du bloc  
 lui-meme, c'est tres courant. Exemple : 
 #include"iostream.h" 
 
 class ordi 
 {float gprix(float a);.......;} 
 
 float ordi::gprix(float a) 
 {prix=a;} 
 
 main() 
 {......;} 
 syntaxe : type nomdeclasse::nomdefonction(paramStres) 
 
 Autre chose : il existe des constructeurs et destructeurs de classe par  
 defaut dans le compilateur, mais on peut en initialiser soi-meme en  
 ajoutant deux fonctions dans la classe, ordi en l'occurence : 
 -ordi(); //constructeur 
 -~ordi(); //destructeur 
 (Rem : //fait suivre un commentaire, evidemment non-interprete par le  
 compilateur) 
 Si on avait mis ces deux fonctions dans le programme, ordi() se serait  
 mis en place des qu'on aurait declarer pc, et ~ordi() automatiquement .  
 la fin du programme. on aurait pu le liberer avant par l'instruction  
 pc.~ordi() si on avait plus besoin de pc et qu'on voulait liberer de la  
 memoire vive. 
 On peut aussi associer des instructions aux constructeurs et aux  
 destructeurs, par exemple : 
 ordi(){cout<<"nouvel ordi"<<'\n';} 
 ~ordi(){cout<<"fin de l'ordi";} 
 
 Voila c'est deja plutot bien pour un debut, non ?