Les variables locales a une fonction ne sont donc pas partageable avec le code qui appelle une fonction, avec d'autres fonctions ou entre plusieurs appels d'une même fonction. Il est donc nécessaire de pouvoir partager des informations entre une fonction et le reste du code. Cela est réalisé via les paramètres de fonction. Pour rappel, la syntaxe générale d'une fonction est la suivante :

PARAMETRE_SORTIE NOM_FONCTION (PARAMETRES_ENTREE) {
    INSTRUCTIONS
}

Une fonction va donc pouvoir recevoir zéro, un ou plusieurs paramètres en entrées et zéro ou un paramètre en sortie. Pour commencer, vous allez voir les fonctions qui ne prennent que des paramètres en entrée, les paramètres de sortie seront vu ensuite.

La syntaxe pour déclarer un paramètre de fonction est assez simple : il est identique à une déclaration de variable, avec un type et un identifiant (et une valeur par défaut, qui sera vu ensuite. Considérez pour le moment que le paramètre n'a pas de valeur par défaut).

TYPE IDENTIFIANT

Par exemple, pour une fonction qui prend un entier et une autre qui prend une chaîne de caractères.

void f(int i) {
    ...
}

void g(std::string s) {
    ...
}

Pour la fonction f, le paramètre est int i, qui est déclaré avec un type int et une identifiant i. Même chose pour g, qui contient un paramètre de type std::string et qui s'appelle s.

En pratique, un paramètre s'utilise de la même façon qu'une variable locale (en particulier, un paramètre suit les mêmes règles concernant la portée et la durée de vie : vous pouvez utiliser un paramètre dès qu'il est déclaré et jusqu'à la fin de la fonction).

Par exemple, pour afficher les valeurs des paramètres des fonctions f et g.

void f(int i) {
    std::cout << i << std::endl;
}

void g(std::string s) {
    std::cout << s << std::endl;
}

Le dernier point à voir est comment appeler une fonction qui prend un paramètre. Pour cela, vous devez donner une valeur entre les parenthèses lors de l'appel de la fonction (cette valeur s'appelle un argument dans un appel de fonction). Une valeur peut être une variable (constante ou non), une littérale ou une expression.

Il existe différents modes de passage de paramètres, qui seront vu dans la suite. Chaque mode accepte ou non certaines types de valeurs. Pour le moment, le mode de passage de paramètre vu est le “passage par valeur”, ce qui autorise l'utilisation de n'importe quel type de valeur.

Par exemple, pour appeler une fonction qui prend un paramètre :

NOM_FONCTION(VALEUR)

Avec le code d'exemple précédent, vous pouvez donc écrire :

#include <iostream>

void f(int i) {
    std::cout << i << std::endl;
}

void g(std::string s) {
    std::cout << s << std::endl;
}

int main() {
    f(123);        // appel avec une littérale de type entier
    g("hello");    // appel avec une littérale de type chaîne
    
    const int i { 456 };
    f(i);          // appel avec une variable de type entier
    const std::string w { "world "};
    g(w);          // appel avec une variable de type chaîne
}

affiche :

123
hello
456
world 

Notez bien que même si dans cet exemple les variables dans la fonction main et la fonctions f ont le même nom i, ce sont bien deux variables différentes (elles ne sont pas dans le même contexte). Comme vous le voyez avec la fonction g, il n'y a aucune obligation d'utiliser le même nom entre l'appel de la fonction et le paramètre.

Ce qui est logique et souhaitable. Comme vous pouvez appeler une fonction plusieurs fois avec des valeurs différentes (et donc des variables différentes), cela n'aurait pas de sens que l'identifiant dans le paramètre de fonction soit identique à l'identifiant utilisé pour appeler la fonction.

const int i { 123 };
f(i);  // ok
const int j {456 };
f(j);  // ok

void f(paramètres...) {
}


int main() {
    f(arguments...);
}

Pour déclarer une fonction qui prend plusieurs paramètres, vous devez donner la liste des paramètres séparés par une virgule.

TYPE IDENTIFIANT, TYPE IDENTIFIANT, TYPE IDENTIFIANT...

Il n'y a pas de limite théorique dans la norme C++ sur le nombre de paramètres que vous pouvez écrire (A vérifier). Par contre, les compilateurs imposent en général une limite. Et de toute façon, une fonction qui prend trop de paramètres deviendra difficilement lisible et c'est généralement le signe qu'il y a un problème d'organisation dans le code.

Par exemple, pour écrire une fonction qui prendre en paramètre un entier et une chaîne :

void f(int i, std::string s) {
    std::cout << i << std::endl;
    std::cout << s << std::endl;
}

Une fonction qui prend plusieurs paramètres s'appelle en donnant la liste des arguments, séparés aussi par des virgules. Chaque argument est indépendant, vous pouvez mélanger des variables, des constantes, des littérales, des expressions, selon ce qui est autorisé pour chaque paramètre (selon de le mode).

f(123, "hello");

La liste des arguments doit correspondre à la liste des paramètres, aussi bien le nombre que les types.

main.cpp

#include <iostream>
 
void f() {
    std::cout << "f()" << std::endl;
}
 
void g(int i) {
    std::cout << "g() avec i=" << i << std::endl;
}
 
int main() {
    f();    // ok
    f(123); // erreur, trop d'argument
 
    g();    // erreur, pas assez d'argument
    g(123); // ok
}

Lorsqu'un compilateur trouve une fonction qui pourrait correspondre à un appel de fonction (avec le même nom de fonction), mais dont le nombre d'arguments ou les types ne correspondent pas, il produit généralement un message d'erreur indiquant qu'il ne trouve pas de fonction correspondante (“no matching function”) et donne la liste des fonctions qui pourraient convenir.

Il est donc très important de bien lire les messages du compilateur, cela facilite grandement la résolution des problèmes, en indiquant où chercher.

Par exemple, un message d'erreur classique produit par le compilateur Clang dans cette situation :

main.cpp:13:5: error: no matching function for call to 'f'
    f(123);
    ^
main.cpp:3:6: note: candidate function not viable: 
requires 0 arguments, but 1 was provided
void f() {
     ^

Le compilateur indique qu'il ne trouve pas de fonction qui s'appelle f et dont les paramètres sont compatible avec l'appel f(123) (“no matching function”). Il indique à la ligne suivante qu'il connait une fonction f qui pourrait être candidate (“candidate function”), mais qui prend zéro argument (“requires 0 arguments”), alors que l'appel utilise un argument (“but 1 was provided”).

Pour l'appel de la fonction g, le message est le suivant :

main.cpp:15:5: error: no matching function for call to 'g'
    g();   
    ^
main.cpp:7:6: note: candidate function not viable: requires single 
argument 'i', but no arguments were provided
void g(int i) {
     ^

De la même manière, le compilateur indique qu'il ne trouve pas de fonction correspondant à l'appel g(), mais qu'il trouve une fonction qui se nomme g et qui prend un argument.

En plus d'avoir le nombre d'arguments dans un appel de fonction qui doit correspondre au nombre de paramètres déclarés dans une fonction, il faut aussi que les types soient exactement les mêmes ou être implicitement convertible.

Un type est “implicitement convertible” (sous entendu “par le compilateur”) lorsque le compilateur connaît une conversion entre les types et qu'il a le droit de réaliser automatiquement cette conversion.

Par exemple, le compilateur saura convertir sans problème un argument de type entier int en paramètre de type réel double ou une littérale chaîne (de type const char*) en paramètre de type std::string. Par contre, il n'est pas possible de convertir un std::string en std::vector<double> (conversion impossible) ou en const char* (cette conversion est possible en appelant la fonction membre std::string::c_str, mais le compilateur ne peut pas l'appeler implicitement : il faut que la conversion soit écrite explicitement par le développeur).

void f(double d) {
}
 
void g(std::string s) {
}
 
int main() {
    f(123);     // conversion de int entre double
    g("hello"); // conversion de const char* en string
}

En revanche, la conversion (par exemple) d'un argument réel en paramètre entier produira une erreur d'arrondi (comme vous avez vu lors de l'initialisation d'une variable, avec le narrowing).

main.cpp

#include <iostream>
 
void f(int i) {
    std::cout << i << std::endl;
}
 
int main() {
    f(12.34);
    const double x = 12.34;
    f(x);
}

affiche :

main.cpp:8:7: warning: implicit conversion from 'double' to 
'int' changes value from 12.34 to 12 [-Wliteral-conversion]
    f(12.34);
    ~ ^~~~~
main.cpp:10:7: warning: implicit conversion turns floating-point 
number into integer: 'const double' to 'int' [-Wfloat-conversion]
    f(x);
    ~ ^
2 warnings generated.
12
56

Notez que le compilateur fait la différence entre la conversion d'une littérale (-Wliteral-conversion) et la conversion d'une valeur réelle (-Wfloat-conversion). Le résultat de ces arrondis est visible dans le résultat affiché, puisque seules les parties entières sont conservées.

Pour terminer, lorsque les types des arguments et des paramètres ne sont pas du tout compatible, le compilateur indique une erreur spécifique (no known conversion).

main.cpp

#include <iostream>
 
void f(int i) {
    std::cout << i << std::endl;
}
 
int main() {
    f("hello");
}

affiche :

main.cpp:8:5: error: no matching function for call to 'f'
    f("hello");
    ^
main.cpp:3:6: note: candidate function not viable: no known 
conversion from 'const char [6]' to 'int' for 1st argument
void f(int i) {
     ^
1 error generated.

Le paramètre de retour de fonction est une valeur qui est transmission uniquement depuis la fonction vers le code appelant. Pour rappel, la signature générale d'une fonction qui retourne une valeur est la suivante :

PARAMETRE_RETOUR NOM(...)

Lorsqu'une fonction ne retourne aucune valeur, le PARAMETRE_RETOUR est remplacé par void (qui n'est pas un type). Si la fonction retourne une valeur, PARAMETRE_RETOUR est remplacé par le type de la valeur que la fonction retourne.

int                 f();  // retourne un entier
std::string         g();  // retourne une chaîne
std::vector<double> h();  // retourne un tableau

Dans le corps de la fonction, la valeur retournée est indiquée par le mot-clé return suivi de la valeur à retourner. Comme pour les paramètres d'entrées de fonctions, la valeur peut être une littérale, une variable, une constante ou une expression. Et le type de la valeur doit être identique ou implicitement convertible dans le type de retour de la fonction.

int f() {
    return 1;  // retourne la valeur entière 1 (littérale)
}
 
int g() {
    const int i { 123 };
    return 1;  // retourne la valeur entière 123 (constante)
}

Bien sûr, rien n'interdit d'utiliser des paramètres d'entrée pour calculer la valeur à retourner. Par exemple :

int f(int i) {
    return ++i;  // retourne la valeur entière i+1 (expression)
}

Cette dernière syntaxe montre bien l'origine des termes “paramètres d'entrée” et “paramètre de sortie” : une fonction prend des valeurs, réalise des calculs dessus, puis retourne une valeur comme résultat. C'est très proche du concept de fonction en mathématique.

La valeur retournée par une fonction est directement accessible dans la code appelant la fonction. L'appel de la fonction peut être directement utilisé comme valeur, ce qui permet de l'affecter à une variable ou l'utiliser dans une expression. (En fait, un appel de fonction EST une expression).

main.cpp

#include <iostream>
 
int f() { return 123; }
int g(int i) { return ++i; }
 
int main() {
    // initialisation dans une variable
    const auto i = f();
 
    // utilisation dans une expression
    std::cout << (f() + g(123)) << std::endl;
}

Une fonction qui retourne une valeur doit obligatoirement avoir au moins un return. Si ce n'est pas le cas, le compilateur produit un message d'erreur.

main.cpp:4:1: warning: control reaches end of 
non-void function [-Wreturn-type]
}
^

(Ce qui signifie “atteint la fin de la fonction qui n'est pas void”).

Il est possible d'avoir plusieurs return dans une fonction. Lorsque la fonction arrive à un return, elle se termine immédiatement et la suite du code appelant est exécuté.

int f() {
    return 123;
    const int i { 456 };
    return i;
}

Le code à la suite du premier return n'est jamais exécuté et la fonction retourne toujours 123. (Cela n'est pas très utile dans un code aussi simple d'avoir plusieurs return, cela sera intéressant quand vous concevrez des algorithmes plus complexes).

Le mot-clé return peut également être utilisé avec une fonction qui ne retourne aucune valeur. Dans ce cas, return n'est suivi d'aucune valeur.

void f(int i) {
    return;
    ++i;
}

On peut souhaiter pouvoir appeler une fonction avec et sans un argument.

Par exemple f qui prend un entier ou 0 si on en donne aucune valeur

Première solution, surcharger la fonction :

void f() {
    std::cout << "f()" << std::endl;
}

void f(int i) {
    std::cout << "f(int) avec i=" << i << std::endl;
}

int main() {
    f();    // ok, appel de f()
    f(123); // ok, appel de f(int i)
}

Le compilateur trouve à chaque fois deux fonctions avec le même nom, mais pas d’ambiguïté pour savoir laquelle appeler.

Possibilité de simplifier en donnant une valeur par défaut à un paramètre :

void f(int i = 0) {
    std::cout << "f(int) avec i=" << i << std::endl;
}

Dans ce cas, on indique que f peut prendre un entier. Si on ne donne pas de valeur, le compilateur peut utiliser la valeur par défaut :

int main() {
    f();    // ok, appel de f(int i) avec i = 0
    f(123); // ok, appel de f(int i) avec i = 123
}

Bien sûr, il ne faut pas laisser les 2 fonctions, pour éviter les ambiguité :

void f() {
    std::cout << "f()" << std::endl;
}

void f(int i = 0) {
    std::cout << "f(int) avec i=" << i << std::endl;
}

int main() {
    f();    // erreur, appel de f() ou de f(int i) avec i = 0 ?
}

(ou overloading ou polymorphisme ad-hoc)

Polymorphisme : plusieurs fonctions de même nom. Des fonctions peuvent avoir le même nom, tant que les paramètres sont différents :

void f(int i) {
    std::cout << "f(int) avec i=" << i << std::endl;
}

void f(string s) {
    std::cout << "f(string) avec s=" << s << std::endl;
}

Le compilateur choisit la fonction correspondante, selon le type que l'on donne en argument :

void f(int i) {
    std::cout << "f(int) avec i=" << i << std::endl;
}
 
void f(long int i) {
    std::cout << "f(long int) avec i=" << i << std::endl;
}
 
int main() {
    f(1); // 1 est une littérale de type int
    f(2L); // 2L est une littérale de type long int
 
    int i { 1 };
    f(i);
 
    long int l { 2 };
    f(l);
}

affiche :

f(int) avec i=1
f(long int) avec i=2
f(int) avec i=1
f(long int) avec i=2

Le compilateur commence par rechercher s'il connait une fonction avec le nom correspondant. Par exemple pour f(1), il trouve 2 fonctions : f(int) et f(long int). Ensuite il regarde si l'un des types en paramètre correspondant au type en argument. Ici, c'est le cas, il appelle donc f(int).

Si on écrit :

#include <iostream>
 
void f(long int i) {
    std::cout << "f(long int) avec i=" << i << std::endl;
}
 
int main() {
    f(1); // 1 est une littérale de type int
}

Le compilateur trouve la fonction f, mais le paramètre ne correspond pas. Il regarde s'il peut faire une conversion. Ici, oui, on peut convertir implicitement un int en long int. il convertie donc 1 en 1L et appelle f(long int).

S'il ne trouve pas de conversion possible, il lance un message d'erreur. Par exemple, si on appelle f(“du texte”), le compilateur donne :

main.cpp:19:5: error: no matching function for call to 'f'
    f("une chaine");
    ^
main.cpp:3:6: note: candidate function not viable: no known conversion 
from 'const char [11]' to 'int' for 1st argument
void f(int i) {
     ^
main.cpp:7:6: note: candidate function not viable: no known conversion 
from 'const char [11]' to 'long' for 1st argument
void f(long int i) {
     ^
1 error generated.

Ce qui signifie qu'il ne trouve aucune fonction correspond à l'appel de f(“une chaine”), mais qu'il a 2 candidat (2 fonction qui ont le même nom) mais sans conversion possible (“no known conversion”).

Au contraire, dans certain cas, il aura plusieurs possibilités, soit parce que vous déclarez par erreur 2 fonctions avec les mêmes paramètres, soit parce que le compilateur peut faire 2 conversions pour 2 types. Dans le premier cas :

void f() {
   std::cout << "première fonction f" << std::endl;
}

void f() {
   std::cout << "seconde fonction f" << std::endl;
}

produit le message :

main.cpp:7:6: error: redefinition of 'f'
void f(int i) {
     ^
main.cpp:3:6: note: previous definition is here
void f(int i) {
     ^

Quand le compilateur arrive à la ligne 7 et rencontre la seconde fonction f (qu'il connait déjà), il prévient qu'il connait déjà (“redefinition of 'f'”) et que la première version (“previous definition is here”) se trouve à la ligne 3.

L'autre cas est si plusieurs fonctions peuvent correspondent, l'appel est ambigu. Par exemple :

#include <iostream>
 
void f(int i) {
    std::cout << "f(int) avec i=" << i << std::endl;
}
 
void f(long int i) {
    std::cout << "f(long int) avec i=" << i << std::endl;
}
 
int main() {
    f(1u); // 1 est une littérale de type unsigned int
}

affiche le message d'erreur :

main.cpp:12:5: error: call to 'f' is ambiguous
    f(1u); // 1 est une littérale de type int
    ^
main.cpp:3:6: note: candidate function
void f(int i) {
     ^
main.cpp:7:6: note: candidate function
void f(long int i) {
     ^

Il existe une conversion de unsigned int vers int et vers long int. Il n'y a pas de priorité dans les conversions, le compilateur ne sait pas quelle conversion choisir et donc quelle fonction appeler. L'appel est ambuigu (“call to 'f' is ambiguous”), il trouve deux fonctions candidate (“candidate function”).

La méthode qui permet au compilateur de trouver la fonction correspondant à une appel s'appelle la résolution des noms (name lookup)

void foo(bool) { std::cout << "f(bool)" << std::endl; }
void foo(string const&) { std::cout << "f(string)" << std::endl; }
 
foo("abc");