Cours d initiation à la programmation en C++ Johann Cuenin

Cours d initiation à la programmation en C++ Johann Cuenin 11 octobre 2014

2

Table des matières 1 Introduction 5 2 Bases de la programmation en C++ 7 3 Les types composés 9 3.1 Les tableaux............................. 9 3.1.1 Définition et déclaration................... 9 3.1.2 Accès aux éléments et opérations.............. 9 3.1.3 Remarques.......................... 10 3.2 Les structures............................. 11 3.2.1 Définition et déclaration................... 11 3.2.2 Remarques.......................... 12 4 Les pointeurs et références 13 4.1 Les pointeurs............................. 13 4.1.1 Adresse et valeur d un objet................. 13 4.2 Notion de pointeur.......................... 14 4.2.1 Définition et déclaration................... 14 4.2.2 Opérations sur les pointeurs................. 15 4.2.3 Parcours d un tableau à l aide d opérations sur les pointeurs 16 4.2.4 Allocation dynamique.................... 17 4.3 Pointeurs et tableaux......................... 18 4.3.1 Déclaration.......................... 18 4.3.2 tableaux à plusieurs dimensions............... 19 4.3.3 Pointeurs et chaînes de caractères............. 20 4.4 Pointeurs et structures........................ 21 5 Les fonctions 23 5.1 Notion de fonction.......................... 23 5.2 Appel d une fonction et algorithmes récursifs........... 24 5.3 Transmission des paramètres d une fonction et passage par référence 25 5.4 Pointeur sur une fonction...................... 26 5.5 programmation modulaire...................... 27 3

4 TABLE DES MATIÈRES

Chapitre 1 Introduction Ce cours est un cours d initiation à la programmation en langage C++. Il n est pas nécessaire d avoir suivit un cours en langage C, ni même dans n importe quel autre langage. 5

6 CHAPITRE 1. INTRODUCTION

Chapitre 2 Bases de la programmation en C++ 7

8 CHAPITRE 2. BASES DE LA PROGRAMMATION EN C++

Chapitre 3 Les types composés Maintenant que les types de base sont connus, nous allons, dans ce chapitre, faire connaissance avec les types composés : les tableaux et structures. Ces types composés permettent de stocker plusieurs variables et de travailler avec sans lister les déclaration (tableaux). Les structures permettent quant à elle de travailler avec des types utiles pour un utilisateur (cas simple, définir un nombre complexe). 3.1 Les tableaux 3.1.1 Définition et déclaration Définition 3.1.1. Un tableau est un ensemble fini d éléments de même type, stockés en mémoire à des adresses contiguës. La déclaration d un tableau à une dimension se fait de la manière suivante : type nom_du_tableau[nbre_éléments], où nbre_éléments est une expression constante entière positive. Exemple 3.1.1. La déclaration int tab[10]; définit un tableau de 10 entiers appelé tab. En mémoire, 10 4 octets seront utilisés. 3.1.2 Accès aux éléments et opérations Pour accéder aux différents éléments d un tableau, on utilise l opérateur []. Chaque élément est repéré par sa position nommée indice. Attention! tab[i] permet d accéder au i+1ième élément du tableau. Ainsi tab[0] désigne le premier élément du tableau et tab[9] le dernier. Les opérations globales sont a priori impossibles. Il n est par exemple pas possible d écrire "tab1 = tab2 ;". L affectation doit se faire éléments par éléments. Pour l exemple ci-dessus : 9

10 CHAPITRE 3. LES TYPES COMPOSÉS 1 int main(){ 2 const int N=5; 3 int i=0; 4 int tab1[n],tab2[n]; 5 for(i=0, i<n, i++){ 6 tab1[i]=tab2[i]; 7 } 8 return 0; 9 } On peut cependant initialiser un tableau de la façon suivante : par exemple : type nom_du_tableau[n] = {cst_1, cst_2,..., cst_n}, 1 int main(){ 2 const int N=5; 3 int tab[n]={1,2,3,4,5}; 4 return 0; 5 } Attention : si le nombre de données est inférieure à la taille du tableau, seuls les premiers éléments seront initialisés. Si le nombre de données est supérieure à la taille du tableau, le compilateur générera une erreur. 3.1.3 Remarques Un tableau de caractères peut être initialisé directement par une chaîne de caractères. Mais attention, il faut que le tableau ait au moins un élément de plus car le compilateur complète toute chaîne de caractères par le caractère nul. On peut considérer l exemple suivant : 1 const int N=8; 2 char tab[n]="exemple"; Lors de l initialisation d un tableau, on peut ne pas spécifier le nombre d éléments. 1 double tab[]={2.6,1.,3.}; 2 char tab[]="exemple"; mais pas 1 int tab[]; On peut déclarer un tableau à plusieurs dimensions. Par exemple, un tableau en deux dimensions sera appelé matrice. Il s agit en fait d un tableau de tableaux. Par exemple : 1 const int N=3,M=2; 2 int tab[m][n]{{1,2,3},{4,5,6}};

3.2. LES STRUCTURES 11 3.2 Les structures 3.2.1 Définition et déclaration Définition 3.2.1. Une structure est une suite finie d objets de types différents. Les zones mémoires ne sont pas forcément contiguës. Chaque élément est appelé membre ou champ. La syntaxe pour déclarer une structure est la suivante : 1 struct modele 2 { 3 type_1 champ_1; 4 type_2 champ_2; 5... 6 type_r champ_r; 7 }; La déclaration d une structure doit se faire avant le main. Dans le main, pour déclarer une objet de type structure, la syntaxe est 1 struct modele objet; Pour accéder aux différents champs, on utilise l opérateur ".". La syntaxe est la suivante 1 objet.champ_i pour accéder au champ numéro i de l objet "objet". Exemple 3.2.1. Déclarer une structure "complexe" et écrire un programme qui calcule la norme d un nombre complexe. 1 #include<iostream> 2 #include<stdlib> 3 #include<math.h> 4 5 using name space std :: 6 7 struct complexe 8 { 9 double reel; 10 double imaginaire; 11 }; 12 13 int main(){ 14 struct complexe z; 15 z.reel=1; 16 z.imaginaire=2; 17 double norme=sqrt(z.reel*z.reel+z.imaginaire*z.imaginaire); 18 cout<<"la norme de z est "<<norme<<"."<<endl; 19 return 0; 20 }

12 CHAPITRE 3. LES TYPES COMPOSÉS 3.2.2 Remarques on peut déclarer un objet de type structure même si le modèle n a pas été déclarer avant par la syntaxe suivante : 1 struct modele 2 { 3 type_1 champ_1; 4... 5 type_r champ_r; 6 }objet; De plus, contrairement aux tableaux, l opérateur d affectation "=" peut s appliquer directement aux structures. Il faut cependant que le modèle soit le même. Il existe un mot clé permettant d alléger un peut la programmation. Par exemple 1 typedef struct complexe 2 { 3 double reel; 4 double imaginaire; 5 }; 6 7 int main(){ 8 complexe z; 9 return 0; 10 }

Chapitre 4 Les pointeurs et références Le but de ce chapitre est d introduire une notion très importante en programmation en langage C++, celle de pointeurs. Bien que cette notion paresse, au premier abord, compliquée, elle permet par exemple de définir des structures dynamiques qui peuvent évoluer au court du temps. 4.1 Les pointeurs 4.1.1 Adresse et valeur d un objet Définition 4.1.1. On appelle Lvalue tout objet pouvant être placé à gauche d un opérateur d affectation. Une Lvalue est caractérisée par son adresse : l adresse mémoire à partir de laquelle l objet est stocké, sa valeur : ce qui est stocké à cette adresse. 1 int i,j; 2 i=3; 3 j=i; Considérons l exemple suivant : objet adresse valeur i x 3 Les adresse x et y sont des entiers (donc codées j y 3 sur 4 octets). Deux variables différentes ont toujours deux adresses différentes. Dans l exemple, l affectation j=i n opère que sur les valeurs des variables (donc il reste x y). On peut accéder à l adresse d une variable à l aide de l opérateur &. 1 cout<<"i="<<i<<" son adresse est "<<&i<<endl; donne par exemple "i=3 son adresse est x". Mais attention, contrairement à i, &i n est pas une Lvalue, mais une constante. Bien qu en général il n est pas utile de connaître la valeur exacte de l adresse d une variable d autant que celle-ci 13

14 CHAPITRE 4. LES POINTEURS ET RÉFÉRENCES change à chaque exécution du programme, il peut être utile de manipuler les adresses. Nous définissons donc un nouveau type d objets : les pointeurs. 4.2 Notion de pointeur 4.2.1 Définition et déclaration Définition 4.2.1. Un pointeur est un objet (Lvalue) dont la valeur est égale à l adresse d un autre objet. La déclaration d un pointeur se fait de la façon suivante type nom_du_pointeur; La type est le type de l objet pointé. nom_du_pointeur est un identifiant dont la valeur est l adresse d un objet de type "type". Ce type peut être primaire (int, double, char...) ou composé (struct, string...). Comme un pointeur est une Lvalue, sa valeur est modifiable. Par exemple : 1 double *p; Remarque : Il faut bien faire la distinction entre la valeur d un pointeur qui est toujours un entier et le type du pointeur qui dépend du type de l objet vers lequel il pointe. Exemple : Définisson un pointeur p qui pointe vers un entier i 1 int i = 3; 2 int *p; 3 p = &i; On obtient le tableau récapitilatif suivant : objet adresse valeur i x 3 p y x L opérateur unitaire * permet d accéder à la valeur de l objet pointé. Donc *p désigne la valeur de i et vaut 3. Dans notre exemple *p et i sont donc identiques : même valeur, même adresse. objet adresse valeur i x 3 p y x *p x 3 Attention!!! Si la valeur de i ou de *p est modifiée alors les deux sont modifiées! Dans notre exemple, si *p=0 alors la valeur de de i devient nulle. Il faut donc faire attention à la manipulation dans un programme! On peut manipuler les deux objets, p et *p à la fois mais les manipulations sont bien différentes!! Par exemple :

4.2. NOTION DE POINTEUR 15 1 int main(){ 2 int i=2, j=6; 3 int *p1, *p2; 4 p1=&i; 5 p2=&j; 6 *p1=*p2; 7 return 0; 8 } on a donc avant la dernière ligne objet adresse valeur i x 2 j y 6 p1 z x p2 t y et objet adresse valeur i x 6 j y 6 p1 z x p2 t y après la dernière ligne. Le programme suivant donne un autre résultat. 1 int main(){ 2 int i=2, j=6; 3 int *p1, *p2; 4 p1=&i; 5 p2=&j; 6 p1=p2; 7 return 0; 8 } objet adresse valeur i x 2 j y 6 p1 z x p2 t y 4.2.2 Opérations sur les pointeurs La valeur d un pointeur (ie l adresse de la variable vers laquelle il pointe) étant un entier, on peut lui appliquer des opérations arithmétiques classiques qui sont : l addition d un entier à un pointeur. Le résultat sera un pointeur de même type que le pointeur de départ. La soustraction d un entier à un pointeur. Le résultat sera un pointeur de même type que le pointeur de départ. La différence de deux pointeurs pointant tous les deux vers des objets de même type. Le résultat est un entier.

16 CHAPITRE 4. LES POINTEURS ET RÉFÉRENCES La somme de deux pointeurs n est pas autorisée! Addition et soustraction d un entier à un pointeur Soit i un entier et p un pointeur sur un objet de type "type". Alors p+i désigne un pointeur sur un objet de type "type" dont la valeur est égale à la valeur de p incrémentée de i*sizeof(type) (p+i=p+i*sizeof(type)). Pour la soustraction on obtient p-i=p-i*sizeof(type). Les deux exemples suivants permettent de comprendre : 1 int main(){ 2 int i=3; 3 int *p1,*p2; 4 p1=&i; 5 p2=p1+1; 6 cout<<"p1= "<<p1<<endl; 7 cout<<"p2= "<<p2<<endl; 8 return 0; 9 } Ici, si on suppose que la valeur de p1 est x alors le programme va afficher "p1 = x" et "p2=x+4". En effet, p1 étant un pointeur sur entiers, et un entier étant codée sur 4 bytes, on ajoute bien 4. 1 int main(){ 2 double i=3; 3 double *p1,*p2; 4 p1=&i; 5 p2=p1+1; 6 cout<<"p1= "<<p1<<endl; 7 cout<<"p2= "<<p2<<endl; 8 return 0; 9 } Ici on obtiendra "p2=x+8". En effet, p1 est un pointeur qui pointe sur un double, codé sur 8 bytes. Remarques : Les opérateurs de comparaison sont également applicables aux pointeurs si tant est qu ils pointent vers des objets de même type. Addition de deux pointeurs Si p et q sont deux pointeurs sur des objets de type "type", alors p-q désigne un entier dont la valeur est égale à (p-q)/sizeof(type). 4.2.3 Parcours d un tableau à l aide d opérations sur les pointeurs Grâce à l utilisation des opérateurs arithmétiques sur les pointeurs, il est possible de parcourir des tableaux. En effet, tout tableau en C/C++ est un pointeur constant dont la valeur est l adresse du premier élément, i.e. tab a

4.2. NOTION DE POINTEUR 17 pour valeur &tab[0]. On peut donc utiliser un pointeur initialisé à tab pour parcourir les éléments du tableau : 1 int main(){ 2 const int N=5; 3 int tab[n]={1,2,6,0,10}; 4 int *p; 5 for(p=&tab[0] ; p<=&tab[n-1] ; p++){ 6 cout<"*p="<<*p<<endl; 7 } 8 return 0; 9 } Ce programme affichera les entiers contenus dans le tabeleau. 4.2.4 Allocation dynamique Définition et syntaxe Avant de manipuler un pointeur, il faut l initialiser. On a déjà vu qu on peut initialiser un pointeur en lui affectant l adresse d une variable. Soit p un pointeur, il est également possible d affecter directement une valeur à *p. On ne peut pas faire : 1 int *p; 2 *p=3; Le compilateur nous renverra une erreur "segmentation fault". En effet, pour pouvoir affecter directement une valeur à *p, il faut d abord réserver à *p un espace mémoire. L adresse de cet espace sera la valeur de p. Définition 4.2.2. On appelle allocation dynamique l opération consistant à réserver un espace mémoire pour stocker l objet pointé. En C++, l allocation dynamique se fait par l opérateur "new". La syntaxe est nom_pointeur = new type; Pour libérer la mémoire, on utilise l opérateur "delete". La syntaxe est Par exemple : 1 int *p; 2 p=new int; 3 *p=3; 4 delete p; delete nom_pointeur; Attention!!! pour pouvoir gérer correctement la mémoire et pour éviter tout désagrément, il faut que tout espace mémoire dédié à un pointeur soit détruit à la fin de chaque execution.

18 CHAPITRE 4. LES POINTEURS ET RÉFÉRENCES Spécificités de l allocation dynamique Il faut bien noter les différences entre l allocation dynamique et les allocations que l on a fait précédemment. Prenons deux exemples 1 int i=2; 2 int *p; 3 p=&i; et 1 int i=2; 2 int *p=new int; 3 *p=i; 4 delete p; Les valeurs et adresses des objets sont donnés dans les tableaux suivants : objet adresse valeur i x 2 p y x *p x 2 et, avant le delete pour le second exemple objet adresse valeur i x 2 p y x *p x 2 Dans le premier cas, la modification de i ou *p va modifier *p ou i respectivement, car ils ot la même adresse. L allocation n est donc pas dynamique, elle se fait par référence. Dans le second cas, la modification de i ou *p n implique pas la modification de *p ou de i. En effet, les adresses sont différentes. Il y a donc une allocation dynamique. 4.3 Pointeurs et tableaux Une des utilisation en C/C++ des pointeurs est la manipulation de tableaux. Nous avons déjà vu comment accéder aux différents éléments d un tableaux grace à un pointeur. Dans le chapitre précédent que la taille des tableau était une constante connue lors de l éxécution. Il est évident que la taille d un tableau peut ne pas être connue avant l éxécution. On introduit donc ici la notion de tableaux dynamiques. 4.3.1 Déclaration Remarque préliminaire L opérateur "new" permet aussi d allouer un espace pour plusieurs objets contigus en mémoire :

4.3. POINTEURS ET TABLEAUX 19 1 int n=2; 2 int i=3, j=6; 3 int *p=new int[n]; 4 *p=i; 5 *(p+1)=j; 6 delete []p; Comme vu plus haut, les tableaux sont des pointeurs constants. Pour accéder à l élément d indice i pour tab, on utilise tab[i]. Pour un pointeur, on peut utiliser p[i]. On a dont la formule p[i]=*(p+i). Pointeurs et tableaux se manipulent donc exatcement de la même manière. Mais la manipulation de tableaux et de non de pointeurs a plusieurs inconvénients : tableaux de taille fixe, impossibilité de construire des tableaux bidimensionnels dont les lignes n ont pas toutes le même nombre d éléments. Mais tout cela devient possible dès que l on manipule des pointeurs alloués dynamiquement. Tableaux dynamiques Pour déclarer un tableau dynamiquement, on peut suivre la syntaxe cidessous 1 int main(){ 2 int n; 3 int *tab; 4 tab=new int[n]; 5 delete[] tab; 6 return 0; 7 } Remarques : Un pointeur doit toujours être initialisé, ce qui n est pas le cas du tableau. De plus, un tableau n est pas une Lvalue, on ne peut donc pas faire d arithmétique dessus. 4.3.2 tableaux à plusieurs dimensions On rappelle qu un tableau à deux dimensions est un tableau de tableaux. C est donc un pointeur qui pointe vers un pointeur. Par exemple, en déclarant int tab[m][n], tab est un pointeur (constant) qui pointe vers un objet qui est lui-même un pointeur d entier. tab a une valeur constante égale à l adresse du premier élément du tableau, &tab[0][0]. De même, pour tout i qui varie entre 1 et M-1, tab[i] est un pointeur constant dont la valeur est l adresse du premier élément de la ligne d indice i, i.e. &tab[i][0]. Comme pour les tableaux à une dimension, les pointeurs de pointeurs ont de nombreux avantages sur les tableaux multidimensionnels. La syntaxe qui permet de déclarer un tableau à deux dimensions est type nom_du_pointeur;

20 CHAPITRE 4. LES POINTEURS ET RÉFÉRENCES et pour un tableau en trois dimensions type nom_du_pointeur; On peut par exemple créer une matrice à k lignes et n colonnes, inconues lors de l éxécution : 1 int main(){ 2 int k,n; 3 int **p; 4 p= new int*[k]; 5 for(int i=0 ; i<k ; i++){ 6 p[i]=new int[n]; 7 } 8 9 for(int i=0 ; i<k ;i++){ 10 delete[] p[i]; 11 } 12 delete[] p; 13 return 0; 14 } Remarques Contrairement aux tableaux, on peut choisir des tailles différentes pour chacune des lignes de p[i]. Par exemple, si on veut que p[i] contienne exactement i+1 éléments on écrira 1 for(i=0 ; i<k ; i++){ 2 p[i]=new int[i+1]; 3 } 4.3.3 Pointeurs et chaînes de caractères On a vu dans le chapitre précedent qu une chaîne de caractères était un tableau à une dimenstion d objet de type char se terminant par le caractère nul \0. On peut donc manipuler toute chaîne de caractères à l aide d une pointeur sur une objet de type char : 1 char *chaine; 2 chaine="ceci est un exemple"; On peut alors facilement connaître le nombre de caractères : 1 int main(){ 2 int i; 3 char *chaine; 4 chaine="ceci est un exemple"; 5 for(i=0 ; *chaine!= \0 ; i++){ 6 chaine++; 7 } 8 cout<<"nombre de caracteres ="<<i<<endl; 9 return 0; 10 }

4.4. POINTEURS ET STRUCTURES 21 4.4 Pointeurs et structures

22 CHAPITRE 4. LES POINTEURS ET RÉFÉRENCES

Chapitre 5 Les fonctions Dans ce chapitre nous allons apprendre, grâce aux fonctions, à programmer de façon efficace. En effet, les fonctions permettent de découper le code. Cela a plusieurs avantages. Premièrement, on évite de réécrire une partie du code qui est utilisé plusieurs fois pour faire la même chose (initialisation de tableaux, affichage ou saisie de structures, calculs redondants...). Ensuite, un code bien structuré est bien plus facile à débuguer! Un programme en C/C++ peut donc être (doit être) découpé en plusieurs fonctions : une fonction principale (en C++, c est la fonction "main" de votre fichier "main.cpp"), plusieurs fonctions auxiliaires. 5.1 Notion de fonction Une fonction est définie par le texte de son algorithme qu on appelle corps de la fonction. Une fonction doit être déclarée avant la fonction principale. La déclaration en C++ se fait de la manière suivante : 1 type nom_fonction{type_1 arg_1, type_2 arg_2,..., type_n arg_n){ 2 -variables locales 3 instructions 4 } Dans la déclaration précédente, le type est le type que doit renvoyer la fonction. C est une type de base ou un type composé, ou même un pointeur! Si la fonction ne renvoie rien, on utilise le mot clé "void" (vide en anglais). Le nom de la fonction est un nom composite qui permettra de l identifier. Les variables arg sont appelés arguments et sont des variables typées (de base ou composés). Elles n ont de valeur qu à l intérieur de la fonction. Par exemple, voici une fonction qui affiche la valeur d une variable entière : 1 void afficher(int a){ 2 cout<<"la variable est egale a "<<a<<endl; 3 } 23

24 CHAPITRE 5. LES FONCTIONS Une fonction est complètement caractérisée par son nom mais aussi par le type renvoyé ou par les types des variables passées en argument. Par exemple les fonctions 1 void afficher(int i) 2 void afficher(float f) sont deux fonctions différentes bien qu ayant le même nom. C est en fait l analogue des fonctions en mathématiques. En effet les fonctions et f : R R + x x 2 f : R + R + x x 2 sont différentes car elles n ont pas le même ensemble de départ. Comme une fonction peut retourner quelque chose, il faut utiliser le mot clé "return" à la fin des instructions. La syntaxe est 1 return (expression); La valeur de l expression est la valeur que va retourner la fonction. Son type doit être le même que celui qui a été spécifié dans l en-tête de la fonction. Par exemple 1 int somme(int a, int b){ 2 return (a+b); 3 } 5.2 Appel d une fonction et algorithmes récursifs Considérons notre fonction somme définie plus haut. Pour rappel, cette fonction doit être déclarée avant le programme principal. Pour l appeler dans celui-ci, on va utiliser la syntaxe suivante 1 int main(){ 2 int a, b; 3 cin>>a>>b; 4 cout<<"la somme vaut "<<somme(a,b)<<endl; 5 return 0; 6 } Pour une fonction générique, l appel se fera donc de la façon suivante : 1 nom_fonction(parametre_1,...,paraletre_n);

5.3. TRANSMISSION DES PARAMÈTRES D UNE FONCTION ET PASSAGE PAR RÉFÉRENCE25 Attention!!!! Pour une fonction renvoyant une valeur, on doit pouvoir stocker le résultat renvoyé! Si on reprends l exemple de la somme, l appel peut aussi s écrire (on complète avec la fonction affichage) : 1 int main(){ 2 int a, b, res; 3 cin>>a>>b; 4 res=somme(a,b); 5 afficher(res); 6 return 0; 7 } Dans la liste d instructions d une fonction, on peut très bien en appeler une ou plusieurs autres, si tant est qu elles soient déclarées avant. On peut également appeler la même fonction à l intérieur d elle-même de manière récursive. Cette technique de programmation est très puissante et permet de faire des calculs assez simplement. Par exemple, écrire une fonction qui permet de calculer la puissance entière d un nombre. 1 int puissance(int a, int n){ 2 if(n==0){ 3 return 1; 4 } 5 else{ 6 return(a*puissance(a,n-1)); 7 } 8 } 5.3 Transmission des paramètres d une fonction et passage par référence Considérons l exemple suivant : 1 void remplace(int a, int b){ 2 cout<<"debut de la fonction : a="<<a<<", b="<<b<<endl; 3 a+=5; 4 b=2*(a+b); 5 cout<<"fin de la fonction : a="<<a<<", b="<<b<<endl; 6 } 7 8 int main(){ 9 int a=10, b=20; 10 cout<<"debut du programme principal : a="<<a<<", b="<<b<<endl; 11 remplace(a,b); 12 cout<<"fin du programme principal : a="<<a<<", b="<<b<<endl; 13 reurn 0; 14 } Ce petit programme va donner le résultat suivant :

26 CHAPITRE 5. LES FONCTIONS debut du programme principal : a=10, b=20 debut de la fonction : a=10, b=20 fin de la fonction : a=15, b =70 fin du programme principal : a=10, b=20 En effet, lors de l appel de remplace, il y a transmission des valeurs de a et b. La fonction copie les valeurs dans des emplacements locaux correspondants à ses arguments et travaille avec ses variables locales. Les valeurs de a et b sont donc modifiées uniquement dans la fonction. Pour palier à ce genre de problème, on peut fournir l adresse des variables et travailler avec des pointeurs. On pourra donc réécrire la fonction remplace et son appel de la manière suivante : 1 void remplace(int *a, int *b){ 2 cout... 3 *a=*a+5; 4 *b=2*(*a+*b); 5 cout... 6 } 7 8 int main(){ 9... 10 remplace(&a, &b); 11... 12 } Cependant cette technique peut devenir assez compliquée lorsque le nombre de variables augmente. Une technique plus simple est d utiliser le passage par référence. Attention, cela n existe pour le moment qu en C++. Si l on veut programmer uniquement en C, il faut passer par les manipulations d adresses et de valeurs grâce aux pointeurs. La déclaration se fait de la manière suivante : 1 void remplace(int &a, int &b){ 2 cout... 3 a+=5: 4 b=2*(a+b); 5 cout... 6 } La fonction va en fait considérer un synonyme de chaque variable et travailler dessus. Comme nous l avons vu dans le chapitre précédent, le synonyme (la référence à une variable en somme) a la même adresse et la même valeur que la variable de référence. Il est donc conseillé d utiliser les passages par référence le plus souvent possible (on peut tout à fait transmettre par référence une structure par exemple). 5.4 Pointeur sur une fonction Il est tout à fait possible de passer une fonction comme paramètre d une autre fonction. Pour cela, on va utiliser la puissance des pointeurs. Un pointeur

5.5. PROGRAMMATION MODULAIRE 27 sur une fonction correspond en fait à l adresse du début du code de la fonction. En claire, si on a une fonction ayant l en-tête 1 type fonction(type_1,...,type_n) alors un pointeur sur cette fonction sera de type 1 type (*)(type_1,...,type_n) Considérons, pour comprendre, l exemple suivant : 1 int somme(int a, int b){ 2 return(a+b); 3 } 4 5 int produit(int a, int b){ 6 return(a*b); 7 } On peut donc définir une fonction "opérateur binaire" que l on va écrire 1 int operateur_binaire(int a, int b, int (*f)(int, int)){ 2 return((*f)(a,b)); Pour appeler une telle fonction, on peut procéder de la manière suivante 1 int main(){ 2 int a=10, b=20, choix; 3 cout<<"taper 1 pour une somme, 2 pour un produit"<<endl; 4 cin>>choix; 5 if(choix==1){ 6 cout<<"resultat = "<<operateur_binaire(a,b,somme)<<endl; 7 } 8 if(choix==2){ 9 cout<<"resultat = "<<operateur_binaire(a,b,produit)<<endl; 10 } 11 return 0 12 } 5.5 programmation modulaire Lorsque l on écrit un code de taille conséquente (ce qui arrive très souvent), on se doit de présenter les choses correctement pour faciliter le débugage par soi-même ou une autre personne, et pour permettre une utilisation simple par le plus grand nombre de personnes. Il faut donc premièrement avoir des noms explicites pour ses variables et pour les fonctions (de préférence en anglais). On doit également commenter son code le plus possible (laisser un code sans commentaires et revenir, même seul, 6 mois plus tard est de l ordre du suicide). On se restreindra également dans l utilisation des constantes. Le mot clé "define" peut être utilisé pour définir une constante pour tout le code (par exemple #define gravite 9.81). On prendra gare également à factoriser son code. Utiliser pour

28 CHAPITRE 5. LES FONCTIONS cela une multitude de petites fonction. Cela permettra d éviter les redondances dans le code et rendra la tâche de débugage plus simple. Enfin, ne pas hésiter à fragmenter son projet en plusieurs fichiers. Concrètement : un premier fichier "fonctions.hpp" permettant de déclarer les fonctions. un deuxième "fonctions.cpp" dans lequel on écrira le code en dur des différentes fonctions. On inclura le fichier "fonctions.hpp". enfin un dernier "main.cpp" contenant le programme principal, dans lequel on inclura le fichier "fonctions.h". Le compilateur se chargera de faire le lien entre les différents fichiers. On sera donc en présence d un projet bien structuré (efforts à faire lors de votre projet!). Ceci permettra d avoir de bonnes bases pour la programmation orientée objets qui sera introduite en master.