Les fonctions en c++

Une fonction est un bloc d'instructions nommé qui prend des entrées (paramètres), effectue un traitement et produit une sortie (valeur de retour). L'objectif est de factoriser le code : regrouper les traitements répétitifs en une seule fonction réutilisable.

Structure d'une fonction

type_retour nom_fonction(liste_de_paramètres) {
    // corps de la fonction
}

Une fonction est composée de quatre éléments :

• Type de retour — type de la valeur renvoyée. Si la fonction ne renvoie rien, on utilise void.
• Nom de la fonction — avec la liste de paramètres, il forme la signature de la fonction.
• Paramètres — optionnels. Décrivent le type, l'ordre et le nombre des arguments attendus.
• Corps — instructions définissant le traitement effectué.

Déclaration, définition et appel

  Déclaration (prototype)

int max(int, int); // les noms de paramètres sont optionnels ici

  Définition

int max(int x, int y)
{
    return (x > y) ? x : y;
}

  Appel

int main()
{
    int a = 4, b = 7;
    cout << "max(a, b) = " << max(a, b) << endl; // affiche 7
    return 0;
}

Passage des paramètres

Lors de l'appel d'une fonction, les arguments peuvent être transmis de trois façons. Le choix dépend du besoin : modification de la variable originale ou non.

Passage par valeur

La valeur de l'argument est copiée dans le paramètre formel. Les deux occupent des emplacements mémoire distincts : la fonction ne peut pas modifier la variable originale.

  Exemple — échange sans effet

#include <iostream>
using namespace std;

void echanger(int x, int y)
{
    int c = x; x = y; y = c; // modifie uniquement les copies locales
}

int main()
{
    int a = 4, b = 7;
    echanger(a, b);
    cout << "a = " << a << "  -  b = " << b << endl;
    return 0;
}

a = 4  -  b = 7

Passage par adresse (pointeur)

L'adresse de l'argument est transmise. La fonction reçoit un pointeur et peut modifier la variable originale via l'opérateur de déréférencement *.

  Exemple — échange effectif par pointeurs

#include <iostream>
using namespace std;

void echanger(int *x, int *y)
{
    int c = *x; *x = *y; *y = c;
}

int main()
{
    int a = 4, b = 7;
    echanger(&a, &b); // on passe les adresses
    cout << "a = " << a << "  -  b = " << b << endl;
    return 0;
}

a = 7  -  b = 4

Passage par référence

La référence est un alias de la variable originale. Aucune copie n'est faite ; la fonction travaille directement sur la variable de l'appelant. La syntaxe est plus propre que les pointeurs.

  Exemple — échange effectif par référence

#include <iostream>
using namespace std;

void echanger(int &x, int &y)
{
    int c = x; x = y; y = c;
}

int main()
{
    int a = 4, b = 7;
    echanger(a, b); // pas besoin de &
    cout << "a = " << a << "  -  b = " << b << endl;
    return 0;
}

a = 7  -  b = 4

Adresse vs Référence — Comparaison

Fonctions membres d'une classe

Une fonction membre (ou méthode) est une fonction définie à l'intérieur d'une classe. Elle a accès à tous les membres (données et fonctions) de la classe pour l'objet sur lequel elle est appelée.

  Exemple — getters et setters

#include <iostream>
using namespace std;

class Voiture
{
private:
    int Id;
    double Vitesse;

public:
    Voiture() : Id(0), Vitesse(0) {}

    void setId(int id)       { Id = id; }
    int  getId()             { return Id; }

    void   setVitesse(double v) { Vitesse = v; }
    double getVitesse()         { return Vitesse; }
};

int main()
{
    Voiture v;
    v.setId(2);
    v.setVitesse(300.45);
    cout << "Id = " << v.getId() << "  -  Vitesse = " << v.getVitesse() << endl;
    return 0;
}

Id = 2  -  Vitesse = 300.45

Définir une méthode en dehors de la classe

On peut séparer la déclaration (dans le .h) de la définition (dans le .cpp) en utilisant l'opérateur de résolution de portée ::.

type_retour NomClasse::nomFonction(liste_paramètres) {
    // corps
}

  Exemple — séparation .h / .cpp

// voiture.h
class Voiture {
private:
    int Id;
    double Vitesse;
public:
    Voiture();
    void setId(int);     int getId();
    void setVitesse(double); double getVitesse();
    void rouler(double);
};

// voiture.cpp
#include <iostream>
#include "voiture.h"
using namespace std;

Voiture::Voiture() : Id(0), Vitesse(0) {}

void   Voiture::setId(int a)       { Id = a; }
int    Voiture::getId()            { return Id; }
void   Voiture::setVitesse(double v){ Vitesse = v; }
double Voiture::getVitesse()       { return Vitesse; }
void   Voiture::rouler(double v)   { Vitesse += v; }

Le pointeur this

Le pointeur this est utile dans deux situations :

1. Lever l'ambiguïté entre paramètre et membre

class Point {
private:
    int x, y;
public:
    Point(int x, int y) {
        this->x = x; // this->x = membre, x = paramètre
        this->y = y;
    }
};

2. Retourner une référence à l'objet courant (chaînage)

class Point {
private:
    int x, y;
public:
    Point(int x, int y) : x(x), y(y) {}

    void afficher() { cout << x << endl; }

    Point& moi() { return *this; } // retourne l'objet lui-même
};