------------------------------------------------------------------------------
*3************************** Initiation au C++ *******************************
---------------------------------| Lefty |------------------------------------

Je n'ai ici la pretention que de vous enseigner la base, celle qui vous
permettra, avec un peu d'implication personnelle, de vous faire parvenir a des
resultats tres satisfaisants. Les chapitres developpes seront : 
	-ORGANISATION D'UN PROGRAMME SIMPLE 	
	-FONCTION, APPEL DE FONCTION 

ORGANISATION D'UN PROGRAMME SIMPLE
Un programme, c'est evident, manipule des données. Voici les principaux types
de donnée : 	
	-int   : nombres entiers compris entre -32768 et 32767
	-float : nombre à virgule
	-void  : valeur d'aucun type
	-char  : caractere (lettre,...)
	-enum  : enumeration (exemple enum jour(lundi,mardi,mercredi) la
valeur initiale par defaut est zero, celles qui suivent augmentent de 1)

Remarque : pour les types int et float, on peut faire preceder "long", qui
augmente l'intervalle des valeur. De plus, il faut toujours commencer ses
programmes par un ou plusieurs fichiers d'en-tete, qui vous permettront de
lire certaines instructions. Le fichier d'en-tete de base est <iostream.h> 
(.h ou .hpp sont les extensions caracteristiques des fichiers d'en-tete). Tout
programme commencera donc par : #include <iostream.h> Le programme doit aussi
contenir une fonction principale, la fonction "main". Mais qu'est ce qu'une
fonction ? C'est une declaration, en l'occurrence main( ) ou void main( )
suivi d'un bloc contenant une suite d'instruction (un ; devant succeder a
chaque instruction). Tout le programme s'organise autour de la fonction main.
Les déclarations sont de cette forme : type nom (parametres). Le type est le
type de valeur renvoye par la fonction, un des types vu plus haut. Le type par
defaut est int. Le nom, c'est vous qui l'attribuez, sauf dans le cas de la
fonction principale qui s'appellera toujours main. Les parametres sont les
valeurs qui seront transmises a la fonction, leur type doit etre preciser. La
fonction main ne recoit jamais aucun parametre. 
Voila donc un programme simple :  
#include <iostream.h> 
main( )
{cout<<"bonjour tout le monde"; 
return 0;} 
On a commence par inclure le fichier d'en-tete, puis par declarer la fonction
principale. Aucun type n'ayant ete precise, elle est de type int. Voila
pourquoi elle renvoie 0, une valeur de type int par l'instruction return 0.
L'instruction cout<< permet d'afficher un resultat, ou des caracteres, c'est
un operateur de sortie. L'operateur d'entree est cin>>  exemple: cin>>A on
attribuera la valeur entree par l'utilisateur a A. Il faudra absolument
veiller a ce que le type de la valeur qui sera entrée sera compatible avec le
type de A, sinon, ca va tout faire foirer. Il aurait aussi fallu declarer A
auparavant, par une instruction du genre : int a ;  sous peine de voire
apparaitre un message d'erreur lors de la compilation.

FONCTION, APPEL DE FONCTION
se limiter à la fonction main va un moment, pas plus. Le besoin d'en creer
d'autres, pour se décharger un petit peu, se fait vite ressentir. Si vous en
utilisez d'autres, vous devez en prevenir le compilateur au début, juste apres
l'inclusion du fichier d'en-tete, de cette façon : type nom (parametres) ; Par
exemple, si vous creez une fonction addition qui additionnera deux nombres,
vous devrez indiquer au debut : int addition (int, int) ;  Plus tard dans le
programme, vous creerez la fonctionne elle-meme, qui sera : int addition (int
a, int b) {int addition=a+b; return addition;} Mais voyons ca par la pratique,
par une petite application qui additionnerait deux nombres par un appel de
fonction :  
#include <iostream.h> 
int addition (int, int) ;
void main( )
{int a,b,c ;
cout<<"entrez un nombre"<<'\n' ;
cin>>a ;
cout<<"entrez un deuxième nombre"<<'\n' ;
cin>>b ;
c=addition(a, b);
cout<<"la somme des deux vaut : "<<c;
return ;}

 int addition (int x, int y)
{int addition =x+y ;
return addition ;}

Ce programme est relativement simple : on déclare trois parametres de type int
a la suite, on attribue une valeur aux deux premier, le troisieme est leur
somme, puis on en affiche le resultat. deux choses sont remarquables dans ce
programme : 	
-le type de la fonction main, et donc de la valeur qu'elle renvoie. On peut
remarquer qu'elle ne retourne rien comme valeur, voila donc un apercu de ce
que peut etre le type void. 	
-l'appel a la fonction addition dans la fonction main par l'instruction
c=addition(a, b) ; on transmettra donc les valeur a et b pour les valeurs x et
y dans la fonction addition qui les additionnera puis en retournera le
resultat, qui sera attribue a c. Voila ce qu'est un appel de fonction.
En prevision pour 3d13#4 :
	-NOTIONS DE BASE SUR LES POINTEURS ET LES ALIAS 	
	-NOTIONS DE BASE SUR LES CLASSES