Les Fonctions en C++ Expliquées avec des Exemples de Code Pratiques

Qu'est-ce qu'une fonction en C++ ?

Une fonction en C++ est un bloc de code autonome qui accepte des entrées, les traite et retourne un résultat. En encapsulant des tâches répétées dans une fonction, les développeurs évitent la duplication de code et peuvent réutiliser facilement la logique à travers un programme en fournissant différents paramètres.

Toute application C++ contient au moins une fonction : main(). Le reste du code peut être organisé en fonctions plus petites et spécialisées, améliorant la lisibilité et la maintenabilité.

Le C++ moderne fournit un riche ensemble de fonctions intégrées dans la bibliothèque standard. Vous pouvez les appeler directement sans écrire l'implémentation vous-même.

Dans ce tutoriel, vous découvrirez :

• Ce qu'est une fonction en C++
• Pourquoi les fonctions sont essentielles
• Les fonctions de la bibliothèque standard
• Les fonctions définies par l'utilisateur
• La déclaration et le prototype de fonction
• La définition de fonction
• La syntaxe et la structure
• Comment appeler une fonction
• Le passage d'arguments

Pourquoi utiliser des fonctions ?

Les fonctions offrent de multiples avantages :

• Elles regroupent les instructions liées, rendant le code plus facile à lire et à comprendre.
• Elles éliminent la répétition, réduisant les risques d'erreurs.
• Elles permettent la réutilisation du code à travers différentes parties d'un programme — voire entre projets — en appelant simplement la même fonction.

Fonctions intégrées (built-in)

Les fonctions de la bibliothèque standard sont pré-définies et prêtes à l'emploi. Vous les invoquez simplement ; vous n'avez pas à fournir d'implémentation.

Exemple 1 : Utilisation de sqrt() depuis cmath

#include <iostream>
#include <cmath>
using namespace std;
int main() {
    double num, squareRoot;
    cout << "Entrez un nombre : ";
    cin >> num;
    squareRoot = sqrt(num);
    cout << "La racine carrée de " << num << " est : " << squareRoot;
    return 0;
}

Sortie :

Capture d'écran du programme en cours d'exécution :

Analyse du code :

1. Inclure iostream pour les fonctions d'entrée/sortie.
2. Inclure cmath pour accéder à la fonction sqrt().
3. Utiliser l'espace de noms std pour éviter de préfixer les noms standards.
4. Définir la fonction main() où réside la logique du programme.
5. Déclarer num et squareRoot comme double.
6. Demander à l'utilisateur un nombre.
7. Lire la saisie de l'utilisateur dans num.
8. Appeler sqrt() pour calculer la racine carrée de num.
9. Afficher le résultat.
10. Retourner 0 pour signaler une exécution réussie.

Fonctions définies par l'utilisateur

Les développeurs peuvent créer des fonctions personnalisées pour encapsuler une logique spécifique à leur application.

Exemple 2 : Une fonction de salutation simple

#include <iostream>
using namespace std;
void sayHello() {
    cout << "Bonjour !";
}
int main() {
    sayHello();
    return 0;
}

Sortie :

Capture d'écran du code :

Explication :

1. Inclure iostream pour les E/S console.
2. Mettre l'espace de noms std en portée.
3. Définir sayHello(), une fonction qui affiche un salut.
4. Invoquer sayHello() depuis main().
5. Retourner 0 pour indiquer une terminaison réussie.

Déclaration / Prototype de fonction

Lorsqu'une fonction est définie après main(), le compilateur a besoin de connaître sa signature à l'avance. Un prototype fournit cette information sans le corps de la fonction.

Exemple de prototype :

int addFunc(int, int);

Seuls le type de retour, le nom de la fonction et les types de paramètres sont requis ; les noms des paramètres sont optionnels.

Définition de fonction

Alors qu'un prototype informe le compilateur de l'interface d'une fonction, la définition fournit le corps exécutable.

Exemple de définition :

int addFunc(int num1, int num2) {
    return num1 + num2;
}

Syntaxe

type_retour nom_fonction(liste_parametres) {
    // corps de la fonction
}

Composants clés :

• type_retour – le type de valeur retournée (utilisez void si aucune).
• nom_fonction – identifiant qui fait partie de la signature de la fonction.
• liste_parametres – zéro ou plusieurs paramètres typés.
• corps de la fonction – les instructions qui effectuent la tâche.

Appel d'une fonction

Pour exécuter une fonction, vous devez l'invoquer par son nom et fournir les arguments requis.

Exemple d'appel :

int result = addFunc(3, 5);

Passage d'arguments

Les arguments doivent correspondre à la liste des paramètres de la fonction tant en nombre qu'en type. Des arguments mal adaptés déclenchent des erreurs à la compilation.

Des valeurs par défaut peuvent être spécifiées pour les paramètres, permettant aux appelants d'omettre ces arguments.

Exemple 3 : Addition de deux nombres avec un prototype

#include <iostream>
using namespace std;
int addFunc(int, int); // prototype
int main() {
    int x, y, sum;
    cout << "Entrez deux nombres : ";
    cin >> x >> y;
    sum = addFunc(x, y);
    cout << "La somme de " << x << " et " << y << " est : " << sum;
    return 0;
}
int addFunc(int num1, int num2) {
    return num1 + num2;
}

Sortie :

Capture d'écran :

Explication :

1. Inclure les en-têtes et espaces de noms nécessaires.
2. Déclarer un prototype pour addFunc().
3. Lire deux entiers depuis l'utilisateur.
4. Invoquer addFunc() avec ces valeurs et stocker le résultat.
5. Afficher la somme.
6. Définir addFunc() après main(), en fournissant la logique d'addition des deux paramètres.

Résumé

• Les fonctions regroupent le code lié en blocs réutilisables.
• Elles réduisent la duplication et améliorent la clarté du code.
• Les fonctions de bibliothèque intégrées sont disponibles via les en-têtes ; les fonctions définies par l'utilisateur nécessitent déclaration et définition.
• Les prototypes de fonction informent le compilateur avant la définition réelle.
• La correspondance du nombre et des types d'arguments est obligatoire ; les arguments par défaut offrent de la flexibilité.