Big Tuto : Apprenez le C++

Chapitre 7 : Les fonctions - 2ème partie

Tutoriel présenté par : Robert Gillard (Gondulzac)
Date d'écriture : 28 novembre 2015
Date de révision : -

      Préliminaires 

   Dans le chapitre 6, nous avons vu des fonctions dont les paramètres étaient passés par valeur et dont l'instruction return ne permettait que de renvoyer une seule valeur, or le C++ permet la modification de variables dans une fonction en passant les adresses de ces variables à la fonction ainsi que la possibilité de retourner plus d'une valeur. 

   Nous allons donc voir comment contourner ces obstacles liés aux passages de paramètres en utilisant les références dont nous avons parlé dans le Chapitre 4 : Pointeurs et références.

Retrouvez les projets complets de ce chapitre :

Remarque : A partir de ce chapitre, tous les exemples sont compilés avec VS 2015. Vous pourrez les recompiler avec un autre compilateur si vous le désirez.

   1 – Utilisation de pointeurs ou de références dans une fonction.

         1.1 - Un exemple de fonction qui permute deux nombres

  Le passage de paramètres par références peut se faire soit en passant des pointeurs soit en passant des références à la fonction. Dans le premier cas, ce sont les adresses des variables qui sont passées et leurs contenus modifiés à l'intérieur de la fonction, tandis que dans le second cas il s'agit de références aux variables. Nous allons voir l'exemple d'une fonction qui permute deux nombres. 

   Nous écrirons d'abord ce programme en utilisant le passage de paramètres par valeurs, ainsi nous pourrons mieux analyser ce problème pour voir les modifications à apporter pour obtenir la permutation. 

   Premier exemple : passage de paramètres par valeurs :

   Ce qui donne dans la console :

   Au début de la fonction main() on donne respectivement les valeurs 17 et 34 à deux variables ''nombre1'' et ''nombre2'' de type unsigned int. On affiche les valeurs de ces variables avant l'appel à la fonction Permute() puis on appelle celle-ci.

   Dans la fonction Permute(), on utilise une variable temporaire nommée ''temp'' afin d'effectuer la permutation des valeurs des variables ''val1'' et ''val2'' passées en paramètres. Nous voyons que les valeurs sont bien échangées dans la fonction Permute() mais dès que l'on retourne dans la fonction main(), on retrouve les valeurs initiales de nos variables d'origine. Ce n'est manifestement pas ce que nous voulions faire... 

   Depuis le chapitre 6, nous savons pourquoi cela ne marche pas et nous allons en faire un bref rappel.  Quand dans main() on fait appel à la fonction Permute(nombre1, nombre2), il s'agit en fait des copies de ces variables qui sont passées à la fonction. Ces variables agissent en variables locales dans la fonction et sont détruites au sortir de celle-ci. Donc, bien que les valeurs de ces variables aient été permutées à l'intérieur de la fonction, elles sont détruites dès que la fonction repasse la main à la fonction main(). Et voila pourquoi nous retrouvons nos valeurs initiales dans main(), après l'appel à la fonction Permute(). 

   Deuxième exemple : permutation de deux nombres à l'aide de pointeurs :

   Ce qui donne dans la console :

   Ok, cette fois ça marche... 

   Dans la déclaration de la fonction Permute(), nous utilisons deux pointeurs comme arguments, *valeur1 et *valeur2. Et quand dans main(), nous appelons la fonction Permute(&nombre1, &nombre2), ce n'est plus les copies des variables ''nombre1'' et ''nombre2'' qui sont passées à la fonction mais bien les adresses de ces variables. Nous voyons ensuite dans la définition de la fonction Permute() que ce sont les valeurs contenues à ces adresses qui sont échangées (la permutation se fait à l'aide de la variable ''temp'' ainsi que des pointeurs déréférencés).

   Finalement, dans la fonction main(), après appel à la fonction Permute(), nous retrouvons nos variables ''nombre1'' et nombre2'' dont les valeurs ont bien été permutées. Nous allons maintenant voir notre dernier exemple de permutation de deux valeurs à l'aide de références. 

   Troisième exemple : permutation de deux nombres à l'aide de références :

   Les résultats dans la console sont ceux du précédent projet, il n'y a donc pas lieu de les afficher. 
   Lorsqu'on appelle la fonction Permute(nombre1, nombre2), ce sont les variables ''nombre1'' et nombre2'' qui sont passées en paramètres et non leurs adresses. Cependant, dans la définition de cette fonction, les paramètres sont identifiés comme étant des références de ces variables et c'est sur ces références que s'opère la permutation (dans le chapitre précédent nous avons vu que toute modification d'une référence est répercutée sur la variable à laquelle est liée la référence ).

   Par rapport au projet précédent utilisant des pointeurs, celui-ci, utilisant des références se trouve quelque peu allégé. L'appel de la fonction Permute() à qui l'on passe les variables en paramètres réels se révèle un peu moins lourd que le passage de paramètres avec des pointeurs.

   Il s'ensuit de ces exemples que si, pour l'écriture d'une fonction, vous avez le choix entre pointeurs ou références, préférez ces dernières, le code est plus léger à implémenter et le risque d'erreurs lié à une utilisation plus massive des pointeurs est moins grand. 

        1.2 – Le spécificateur const et passage d'adresses par références

   Si pour l'une ou l'autre raison, les paramètres que vous voulez passer à une fonction et quel que soit leur type, ne peuvent absolument pas être modifiés, vous avez tout intérêt à utiliser le spécificateur ''const'' dans la déclaration et la définition de votre fonction. De même que dans le projet précédent, les paramètres passés à la fonction du projet suivant sont identifiés comme références (mais à des valeurs constantes, cette fois). Un premier exemple simple va vous en démontrer toute l'utilité. 

   Ce qui donne dans la console :

   Les variables nb1 et nb2 ayant été définies comme constantes, il est donc impossible de modifier les valeurs de leurs références dans la fonction Somme().

   Allez...  Une petite question : Aurions-nous pu, à titre d'exemple, dans la définition de la fonction Somme(), lier une seconde référence à la valeur ''rvaleur1'' passée en paramètre à la fonction...? 

   La réponse est oui (pour autant que cette référence soit elle-même une référence d'un const unsigned int) car de même que &rvaleur1 est un alias de la constante nb1, si nous lions une référence ''&ref'' à la constante rvaleur1, la nouvelle référence sera également un alias de la constante nb1 (voir chapitre 4 – paragraphe 1.3 : les références et le qualificateur const pour réviser ! ).

   Dans ce cas nous pourrions écrire la fonction Somme() comme ceci : 

   Et le résultat dans la console :

   Il n'y avait pas besoin de passer par une fonction pour connaître la plus longue des deux chaînes, mais comme nous étudions le passage de paramètres par références dans les fonctions, cet exemple est intéressant à plus d'un titre.

   Nous déclarons une fonction ''EstPlusGrand'', contenant deux ''const string'' en paramètres et retournant un booléen. Dans la définition de la fonction, les paramètres ch1 et ch2 sont identifiés comme étant des références et la fonction ne fait que retourner une expression booléenne (rchaine1 > rchaine2), et que cette expression soit vraie ou fausse, elle va être testée dans la fonction main().

   En effet, dans la fonction main(), la valeur de retour est reçue en testant : if (EstPlusGrand(ch1, ch2))

   Or nous savons que cette valeur de retour sera vraie si l'expression : return (rchaine1 > rchaine2) est vraie, et fausse dans le cas contraire. 

   Et pour terminer l'exemple, nous affichons le nombre de caractères des chaînes avec ch1.size() et ch2.size().

   Je rappelle que la longueur de deux chaînes de caractères n'est pas nécessairement liée au nombre de leurs caractères (voir chapitre 5). Donc dans les chaînes ''Assourdan'' et ''Assourbanipal'', la chaîne la plus grande est bien entendu ''Assourdan'' car le premier caractère différent des deux chaînes est le ''d'' qui a une valeur supérieure à ''b''. 

   Le type chaîne ''size_type''

   Nous savons maintenant que ''size()'' retourne le nombre de caractères d'un tableau de type ''string''. Il semblerait donc logique que size() retourne un entier ou mieux, un unsigned int mais il n'en est rien ; à la place, size() retourne une valeur de type string::size_type.

   Il se fait que la classe ''string'' ainsi que d'autres types de librairies définissent un certain nombre de ce qu'on appelle des ''types compagnons'' ou ''companions types''. Le type size_type est l'un de ces types compagnons et pour pouvoir l'utiliser nous devons ajouter l'opérateur de résolution de portée pour signaler qu'il est défini dans la classe <string>.

   Bien que l'on ne connaisse pas le type précis d'un type ''string::size_type'', nous savons qu'il s'agit d'un type non-signé, assez grand pour contenir n'importe quelle chaîne de caractères. Ceci nous rappelle le type ''size_t'' défini dans le fichier <cstddef> et dont nous avons parlé dans le chapitre 6.

   Et en affichant le nombre de caractères des chaînes avec les variables longueurChaine1 et longueurChaine2 plutôt que ch1.size() et ch2.size(). Dans ce cas, les variables longueurChaine1 et longueurChaine2 sont de type string::size_type. 

   2 – Renvoi de plusieurs valeurs à l'aide de références

        2.1 – Renvoi de valeurs à l'aide de pointeurs

   Une fonction ne peut retourner qu'une seule valeur...  Qui a dit cela ?  Il existe cependant des cas où nous avons besoin qu'une fonction renvoie plusieurs valeurs.  Le C++ nous le permet en effectuant le passage de valeurs par références. Dire que l'on passe des valeurs par références est un terme général qui inclut aussi bien les pointeurs que les références elles-mêmes. 

   Nous allons présenter maintenant un exemple ludique renvoyant plusieurs valeurs à l'aide de pointeurs. 

   Vous avez envoyé 10 fantassins et 10 archers en reconnaissance. L'ennemi leur tend une embuscade et certains d'entre eux sont tués. Nous créons une fonction Survivants() qui vous demandera d'entrer le nombre de fantassins et d'archers tués et elle renverra alors le nombre d'archers et le nombre de fantassins survivants ainsi que le nombre total de survivants. 

   Ce qui pourrait par exemple donner dans la console :

   Si vous entrez des valeurs supérieures aux limites fixées, la fonction vous redemandera d'entrer des nouvelles valeurs ne dépassant pas ces limites. Celles-ci sont bien entendu 0, si vous sortez indemne de cette embuscade et du nombre maximum de 10 fantassins et 10 archers que vous avez envoyés en éclaireurs. 

   Ce qui pourrait avoir pour résultats :

   Nous déclarons une fonction Survivants() qui prend en paramètres un pointeur sur nb_fantassins ainsi qu'un autre pointeur sur nb_archers. Dans la définition de cette fonction, nous déclarons deux variables locales de type unsigned int, nb_fantassins_perdus et nb_archers_perdus. On demande alors à l'utilisateur d'entrer des valeurs qui seront stockées dans ces variables ; ces valeurs doivent être comprises ente 0 et 10 puisque 10, nous venons d'en parler plus haut, est le nombre de fantassins ainsi que le nombre d'archers que vous avez envoyés au casse-pipe ! 

   Le nombre de fantassins et d'archers perdus sont ensuite soustraits du contenu des adresses passées à la fonction par les pointeurs *nb_fantassins et *nb_archers afin d'obtenir le nombre de leurs survivants. Pour terminer, nous retournons le nombre total de survivants à l'aide des pointeurs déréférencés *nb_fantassins et *nb_archers. 

   Voilà pour ce qui est de cet exemple. Les débutants en C++ qui le désirent, pourront également refaire cet exemple à l'aide des références (Exercice 2).

2.2 – Utilisation de ''string::size_type'' comme type de retour d'une fonction

   Nous allons présenter un troisième et dernier exemple en ce qui concerne le renvoi de plusieurs valeurs à l'aide de références dans ce chapitre. Dans cet exemple nous allons rechercher le nombre de fois qu'un certain caractère se retrouve dans une chaîne (le nombre d'occurrences) ainsi que la position de ce premier caractère dans la chaîne. 

   La fonction, nommée Recherche_char(), retournera le type ''string::size_type'' et utilisera les spécificateurs de types ''auto'' et ''decltype'' dans sa définition.

   Et les résultats dans la console : 

   Et bien, un peu d'explications ne ferait pas de mal... 

   Voyons la fonction Recherche_char() en premier. Celle-ci accepte en paramètres une référence à une chaîne de caractères, une variable const char représentant le caractère à rechercher ainsi qu'une référence du nombre d'occurrences du caractère dans la chaîne. Son type de retour est de type string::size_type.

   Dans l'implémentation de la fonction, une variable ''position1'', qui représentera la position de la première occurrence du caractère à rechercher est initialisée à la valeur de la longueur de la chaîne, nous allons voir pourquoi. 

   Nous parcourons une boucle de 0 à chaine_size() - 1 pour rechercher toutes les occurrences de notre caractère. Pour chaque caractère trouvé, on teste ensuite si la variable position1 est bien égale à chaine_size(). Elle l'est, nous l'avons définie plus haut et qui plus est, elle l'est toujours, puisque chaine_size() ne varie pas. Nous donnons donc la valeur de la position du premier caractère trouvé à la variable position1 et on incrémente le nombre d'occurrences. La fonction retourne ensuite la valeur de la variable position1.

   Nous passons maintenant à la fonction main().

   Nous définissons ''Nabuchodonosor'' comme chaîne de type const string ainsi que le caractère 'o' dont nous allons devoir trouver le nombre d'occurrences dans la chaîne. Une variable ''compteur'' de type string::size_type est ensuite initialisée à 0. C'est cette variable qui sera passée en paramètre à la fonction Recherche_char() pour trouver le nombre d'occurrences du caractère 'o' de la chaîne.

   On appelle la fonction Recherche_char() en passant la chaîne de caractères, le caractère à retrouver ainsi que le nombre d'occurrences de ce caractère qui, nous venons de le voir est égal à 0 au départ. On affiche ensuite le nombre d'occurrences du caractère 'o' dans ''Nabuchodonosor'' ainsi que la position de ce premier caractère dans la chaîne. 

   Un petit challenge (Exercice 3)

   Je vous propose de modifier ce programme en y ajoutant la position de chaque occurrence de 'o' dans la chaîne ''Nabuchodonosor'' (en utilisant ce que nous avons appris jusqu'à présent, bien entendu ).

1. Soit vous ajoutez un tableau d'unsigned int en paramètre de la fonction Recherche_char(). Par exemple : uint tab[]. Ce tableau sera destiné à acquérir les valeurs des positions des caractères 'o' dans la chaîne. La fonction doit retourner le tableau. 

2. Soit vous ajoutez un pointeur unsigned int en paramètre de la fonction Recherche_char(). Par exemple : uint *ptrTab. La fonction doit retourner le pointeur. 

   Dans les deux cas, vous devriez avoir un résultat de ce genre dans la console: 

   Les corrigés des trois exercices proposés seront présentés à la fin du chapitre 8. 

@ bientôt pour le Chapitre 8 - Les fonctions (3) !

Gondulzak.