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.