Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

Déclaration d’une fonction opérateur

Une déclaration de fonction opérateur donne à une fonction un nom composé de `operator` suivi de la désignation d’un opérateur surchargeable, par exemple `operator+`. Elle permet de définir le fonctionnement d’un opérateur pour des types définis par l’utilisateur sans modifier sa priorité ni son associativité.

Version : C++23; repository compiler flag, production runtime not attested

Syntaxe

ReturnType operator+(const T& lhs, const T& rhs);
// Alternative member declaration inside T:
ReturnType operator+(const T& rhs) const;

Une déclaration de fonction opérateur utilise un nom tel que operator+. Elle déclare une fonction ou un modèle de fonction ; des instanciations explicites et des spécialisations d’un modèle sont également possibles. La première déclaration de operator+ dans l’exemple ne contient pas de corps de fonction. Un ; final ne suffit toutefois pas à déterminer si une déclaration est une définition : dans la grammaire du C++, = delete; constitue un corps de fonction, de sorte qu’une déclaration qui contient ce corps est une définition.

Pour un opérateur binaire ordinaire comme +, une fonction non membre possède deux paramètres. Autre possibilité : une fonction membre non statique possède un paramètre en plus du paramètre objet ; l’opérande gauche est l’objet. La résolution de surcharge choisit la fonction pour a + b. Dans l’exemple, la fonction non membre sélectionnée est également appelée explicitement sous la forme operator+(a, b).

Une surcharge ordinaire nécessite la participation d’un type classe ou énumération ; elle ne peut donc pas redéfinir l’addition de deux valeurs int. Elle ne modifie ni la priorité, ni l’associativité, ni le nombre d’opérandes. Les opérateurs ., .*, :: et ?: ne peuvent pas être surchargés. Les fonctions d’allocation et de désallocation, ainsi que co_await, suivent des règles distinctes.

L’exemple déclare d’abord operator+, puis le définit. Les deux appels additionnent les champs value et créent un nouveau Score sans modifier les arguments. La sortie attendue est 20 20, suivie d’un retour à la ligne. Cette entrée porte sur C++23 ; le document fourni est un projet de norme en évolution, et non une édition C++23 figée.

Exemples

#include <iostream>

struct Score {
    int value;
};

Score operator+(const Score& lhs, const Score& rhs);

Score operator+(const Score& lhs, const Score& rhs) {
    return Score{lhs.value + rhs.value};
}

int main() {
    const Score a{12};
    const Score b{8};
    const Score sum = a + b;
    const Score direct = operator+(a, b);
    std::cout << sum.value << ' ' << direct.value << '\n';
}

Résultat

20 20

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources