Surcharge en C++

Introduction à la Surcharge

La surcharge permet d'avoir plusieurs définitions d'une fonction ou d'un opérateur à l'intérieur du même contexte. Cela inclut la surcharge de fonction et la surcharge d'opérateur.

Surcharge de Fonction

Créer une surcharge de fonction commence par déclarer une fonction avec le même nom qu'une autre fonction déjà définie, mais avec des paramètres différents.

Remarque : Il est crucial que chaque déclaration possède des paramètres différents. Changer uniquement le type de retour de la fonction ne suffira pas à définir une surcharge.

Syntaxe

Comme une fonction peut être surchargée plusieurs fois, la syntaxe peut varier d'un cas à l'autre. Voici une structure possible d'une fonction surchargée :

functionName(parameters1);
functionName(parameters2);

On peut ajouter d'autres déclarations selon les besoins. La déclaration comprend les éléments suivants : - functionName : Nom de la fonction, identique à chaque définition. - parameters1 et parameters2 : Paramètres de chaque définition, qui doivent être distincts.

Exemple

Prenons un exemple pour illustrer la surcharge de fonction :

#include 
using namespace std;
void multiply(int x, int y) {
    cout << "Le produit de " << x << " et " << y << " est : " << (x*y) << endl;
}
void multiply(double x, double y) {
    cout << "Le produit de " << x << " et " << y << " est : " << (x*y) << endl;
}
int main() {
    multiply(20,10);
    multiply(80.2, 90.99);
}

Les sorties seront :

Le produit de 20 et 10 est : 200
Le produit de 80.2 et 90.99 est : 7297.4

Surcharge d'Opérateur

La surcharge d'opérateur permet de redéfinir les opérateurs standards pour des classes définies par l'utilisateur. Lorsqu'un opérateur surchargé est utilisé, le compilateur détermine quelle définition appliquer en fonction des arguments fournis. Voici quelques opérateurs qui peuvent être surchargés :

Classifications d'Opérateurs

| Catégorie | Opérateurs | Noms | |---------------|-----------------------------------------------------|-------------------------------------------| | Arithmétique | +, -, , /, %, ++, -- | add/positive, subtract/negative, multiply, divide, modulo, increment, decrement | | Assignment | =, +=, =, /=, -=, %=, &=, ^=, |=, <<=, >>= | assign, add & assign, multiply & assign, divide & assign... | | Logique | &&, ||, ! | logique AND, logique OR, logique NON |

Opérateurs Non Surchargeables

Certains opérateurs ne peuvent pas être surchargés, tels que : - Conditionnel (ou Terniaire) : ? - Portée : ::

Syntaxe

class className {
  public:
    returnType operator symbol(arguments) {
      // code ici
    }
};

Dans cette syntaxe : - className : Nom de la classe. - returnType : Type de retour de la fonction. - symbol : L'opérateur à surcharger. - arguments : Arguments nécessaires.

Exemple de Code

Voici un exemple qui surcharge l'opérateur plus (+) dans une classe Pyramid, permettant d'accumuler le volume de deux pyramides :

class Pyramid {
public:
    double baseArea;
    double height;
    Pyramid(double b, double h) : baseArea(b), height(h) {}
    double volume() { return (1.0 / 3.0) * baseArea * height; }
    Pyramid operator+(Pyramid const &p) {
        return Pyramid(this->baseArea + p.baseArea, this->height + p.height);
    }
};