Introduction aux fonctions en C++ : définition, appel, paramètres

En C++, les fonctions sont des blocs de code réutilisables qui accomplissent une tâche spécifique. Elles permettent de garder les grands programmes organisés, lisibles et faciles à maintenir. Dans cet article, nous allons apprendre pas à pas comment définir, appeler, utiliser des paramètres et gérer les valeurs de retour d’une fonction.

1. Qu’est-ce qu’une fonction ?

Une fonction est un bloc de code indépendant qui exécute une opération et peut éventuellement retourner une valeur. La structure générale d’une fonction en C++ est la suivante :

type_de_retour nomDeFonction(paramètres) {
    // Corps de la fonction
}

Exemple :

int Addition(int a, int b) {
    return a + b;
}

Cette fonction prend deux entiers et renvoie leur somme.

2. Les 4 composants d’une fonction

3. Définir et appeler une fonction

Les fonctions peuvent être appelées à l’intérieur ou à l’extérieur de la fonction main(). En général, elles sont définies à l’extérieur et appelées à l’intérieur de main().

#include <iostream>
using namespace std;

int Addition(int x, int y) {
    return x + y;
}

int main() {
    int resultat = Addition(5, 8);
    cout << "Somme : " << resultat << endl;
    return 0;
}

Lors de l’appel de la fonction, les paramètres sont passés dans l’ordre. Dans l’appel Addition(5, 8), x=5 et y=8.

4. Type de retour (return)

Une fonction peut renvoyer un résultat à l’endroit où elle a été appelée. Cette valeur est spécifiée avec l’instruction return.

double Moyenne(int a, int b, int c) {
    return (a + b + c) / 3.0;
}

int main() {
    cout << "Moyenne : " << Moyenne(70, 85, 90) << endl;
}

Si la fonction ne retourne aucune valeur, elle est déclarée avec le type void.

void AfficherMessage() {
    cout << "Bonjour, C++ !" << endl;
}

5. Utilisation des paramètres

Les fonctions peuvent recevoir des paramètres pour exécuter des opérations dynamiques. Les paramètres peuvent être passés par valeur ou par référence.

Passage par valeur

Une copie de la variable est transmise à la fonction. La variable d’origine n’est pas modifiée.

void ChangerValeur(int x) {
    x = x + 10;
}

int main() {
    int nombre = 5;
    ChangerValeur(nombre);
    cout << nombre; // 5
}

Passage par référence

Le symbole & permet de passer directement la variable elle-même. Les modifications effectuées dans la fonction affectent la variable d’origine.

void ChangerValeur(int &x) {
    x = x + 10;
}

int main() {
    int nombre = 5;
    ChangerValeur(nombre);
    cout << nombre; // 15
}

6. Paramètres par défaut

En C++, il est possible de définir des valeurs par défaut pour les paramètres. Si un argument n’est pas passé lors de l’appel, la valeur par défaut est utilisée.

void Saluer(string nom = "Visiteur") {
    cout << "Bonjour, " << nom << " !" << endl;
}

int main() {
    Saluer();         // Bonjour, Visiteur !
    Saluer("Alice");  // Bonjour, Alice !
}

7. Déclaration de fonction (Prototype)

Si une fonction est appelée avant que le compilateur ne connaisse sa définition, une erreur se produira. Dans ce cas, la signature (prototype) de la fonction doit être déclarée au préalable.

// Déclaration
int Addition(int a, int b);

int main() {
    cout << Addition(3, 4);
}

// Définition
int Addition(int a, int b) {
    return a + b;
}

8. Surcharge de fonction (Function Overloading)

En C++, plusieurs fonctions peuvent porter le même nom, à condition que le nombre ou le type de paramètres diffère.

int Addition(int a, int b) {
    return a + b;
}

double Addition(double a, double b) {
    return a + b;
}

int main() {
    cout << Addition(3, 4) << endl;     // version int
    cout << Addition(2.5, 4.1) << endl; // version double
}

9. Exemple : Calculs géométriques

L’exemple suivant montre comment plusieurs fonctions peuvent être utilisées pour différents types de calculs.

#include <iostream>
using namespace std;

double AireCarre(double cote) {
    return cote * cote;
}

double AireRectangle(double largeur, double hauteur) {
    return largeur * hauteur;
}

int main() {
    cout << "Aire du carré : " << AireCarre(4) << endl;
    cout << "Aire du rectangle : " << AireRectangle(3, 5) << endl;
    return 0;
}

Cet exemple illustre comment plusieurs fonctions peuvent être définies et appelées dans le même programme.

10. TL;DR

Articles connexes