Surcharge en C++

C++ ne permet pas à une fonction qui ajoute deux entiers et renvoie un entier, d'ajouter deux flottants et de renvoyer un flottant. Imaginez qu'il existe une fonction pour additionner deux entiers et renvoyer un entier. Ne serait-il pas agréable d'avoir une autre fonction du même nom, qui n'ajoute que deux flotteurs ou même plus pour renvoyer un flotteur? On dit que cela surcharge la première fonction.

Les opérateurs arithmétiques sont généralement utilisés pour les opérations arithmétiques. N'est-il pas agréable d'avoir le +, joindre deux cordes? L'activation de la surcharge de l'opérateur d'addition arithmétique, pour les chaînes.

L'opérateur d'incrémentation, ++ ajoute 1 à un int ou un float. Lorsqu'il s'agit de pointeurs, il n'ajoute pas 1 au pointeur. Il fait pointer le pointeur vers le prochain objet consécutif en mémoire. Un itérateur pointe vers l'objet suivant dans une liste chaînée, mais les objets de la liste chaînée sont à des endroits différents en mémoire (pas dans des régions consécutives). Ne serait-il pas agréable de surcharger l'opérateur d'incrémentation pour un itérateur, pour incrémenter mais pointer sur l'élément suivant, dans la liste chaînée?

Cet article explique la surcharge en C++. Il est divisé en deux parties : surcharge de fonction et surcharge d'opérateur. Avoir déjà des connaissances de base en C++ est nécessaire pour comprendre la suite de l'article.

Contenu de l'article

Surcharge de fonction
Surcharge de l'opérateur
Exemple de surcharge d'opérateur de classe de chaîne
Surcharge de l'opérateur de l'itérateur
Conclusion

Surcharge de fonction

La fonction suivante ajoute deux entiers et renvoie un entier :

int ajouter(int no1, int no2)

somme int = no1 + no2 ;
somme de retour ;

Le prototype de cette fonction est :
int add(int no1, int no2) ;
Le prototype d'une fonction dans l'en-tête de la fonction, se terminant par un point-virgule. La fonction suivante avec le même nom, mais avec un prototype différent, ajouterait trois flottants et renverrait un flottant :
float ajouter(float no1, float no2, float no3)

somme flottante = no1 + no2 + no3 ;
somme de retour ;

Comment le compilateur différencie-t-il la fonction à appeler, puisque deux fonctions ou plus ont le même nom? Le compilateur utilise le nombre d'arguments et les types d'arguments pour déterminer quelle fonction appeler. La liste des paramètres des fonctions surchargées doit différer par leur nombre et/ou leurs types de paramètres. Ainsi, l'appel de fonction,

int sm = ajouter(2, 3);

appellerait la fonction entière, tandis que l'appel de fonction,

float sme = add(2.3, 3.4, 2.0);

appellerait la fonction float. Remarque : il existe des situations où le compilateur rejettera une fonction surchargée lorsque le nombre d'arguments est le même mais de types différents! - Raison : - voir plus tard.

Le programme suivant met les segments de code ci-dessus en action :

#inclure
en utilisant l'espace de noms std ;
int ajouter(int no1, int no2)

somme int = no1 + no2 ;
somme de retour ;

float ajouter(float no1, float no2, float no3)

somme flottante = no1 + no2 + no3 ;
somme de retour ;

int main()

int sm = ajouter(2, 3);
cout<float sme = add(2.3, 3.4, 2.0);
cout<renvoie 0 ;

La sortie est :
5
7.7

Surcharge de l'opérateur

Les opérateurs arithmétiques sont utilisés pour surcharger les opérations dans les types de classe. Un itérateur est un type de classe. Les opérateurs d'incrémentation et de décrémentation sont utilisés pour surcharger les opérations d'un itérateur.

Exemple de surcharge d'opérateur de classe de chaîne

Cette section fournit un exemple, où + est surchargé pour une classe de chaîne de conception simple, appelée classe de ressort. + concatène les littéraux de deux objets chaîne, renvoyant un nouvel objet avec les littéraux concaténés. Concaténer deux littéraux signifie joindre le deuxième littéral à la fin du premier littéral.

Maintenant, C++ a une fonction membre spéciale pour toutes les classes, appelée l'opérateur. Le programmeur peut utiliser cette fonction spéciale pour surcharger des opérateurs, tels que +. Le programme suivant montre la surcharge de l'opérateur + pour deux chaînes.

#inclure
en utilisant l'espace de noms std ;
printemps de classe

Publique:
//données membres
car val[100];
entier n;
char concat[100];
//fonctions membres
ressort (char arr[])

pour (int i=0; i<100; ++i)
val[i] = arr[i];
si (arr[i] == '\0')
Pause;

int je;
pour (i=0; je<100; ++i) if (arr[i] == '\0') break;
n = je;

opérateur ressort+(ressort& st)
int newLen = n + st.n;
char newStr[newLen+1];
pour (int i=0; ipour (int i=n; inewStr[newLen] = '\0';
spring obj(newStr);
retour obj;

;
int main()

char ch1[] = "Je te déteste! "; ressort str1(ch1);
char ch2[] = "Mais elle t'aime!"; ressort str2(ch2);
car ch3[] = "un" ; ressort str3(ch3) ;
str3 = str1 + str2;
cout<renvoie 0 ;

La valeur de str1 est "Je te déteste! ". La valeur de str2 est "Mais elle t'aime!". La valeur de str3, c'est-à-dire str1 + str2, est la sortie :

"Je te déteste! Mais elle t'aime!"

qui est la concaténation des deux chaînes littérales. Les chaînes elles-mêmes sont des objets instanciés.

La définition de la fonction opérateur est à l'intérieur de la description (définition) de la classe de chaîne. Il commence par le type de retour, "spring" pour "string". Le nom spécial, "opérateur, suivez ceci". Après cela, il y a le symbole de l'opérateur (à surcharger). Ensuite, il y a la liste de paramètres, qui est en fait la liste d'opérandes. + est un opérateur binaire : ce qui signifie qu'il prend un opérande gauche et droit. Cependant, par la spécification C++, la liste de paramètres ici n'a que le bon paramètre. Ensuite, il y a le corps de la fonction d'opérateur, qui imite le comportement ordinaire de l'opérateur.

Par la spécification C++, la définition de l'opérateur + ne prend que le paramètre de l'opérande droit, car le reste de la description de la classe est le paramètre de l'opérande gauche.

Dans le code ci-dessus, seule la définition de la fonction opérateur+(), est concernée par la surcharge +. Le reste du code de la classe est un codage normal. À l'intérieur de cette définition, les deux littéraux de chaîne sont concaténés dans le tableau, newStr[]. Après cela, un nouvel objet chaîne est réellement créé (instancié), en utilisant un argument, newStr[]. A la fin de la définition de la fonction opérateur+(), l'objet nouvellement créé, ayant la chaîne concaténée, est renvoyé.

Dans la fonction main(), l'ajout se fait par l'instruction :

str3 = str1 + str2;

Où str1, str2 et str3 sont des objets chaîne qui ont déjà été créés dans main(). L'expression "str1 + str2" avec son +, appelle la fonction membre operator+() dans l'objet str1. La fonction membre operator+() dans l'objet str1 utilise str2 comme argument et renvoie le nouvel objet avec (développé) la chaîne concaténée. L'opérateur d'affectation (=) de l'instruction complete, remplace le contenu (valeurs des variables) de l'objet str3, par ceux de l'objet retourné. Dans la fonction main(), après ajout, la valeur de la donnée membre str3.val n'est plus "un" ; il s'agit de la chaîne concaténée (addition), "Je te déteste! Mais elle t'aime!". La fonction membre operator+() dans l'objet str1, utilise le littéral de chaîne de son propre objet et le littéral de chaîne de son argument, str2 pour créer un littéral de chaîne joint.

Surcharge de l'opérateur de l'itérateur

Lorsqu'il s'agit de l'itérateur, au moins deux objets sont impliqués : une liste chaînée et l'itérateur lui-même. En fait, au moins deux classes sont impliquées : une classe à partir de laquelle une liste chaînée est instanciée, et une classe à partir de laquelle un itérateur est instancié.

Liste chaînée

Un diagramme pour un objet de liste doublement chaînée est :

Cette liste comporte trois éléments, mais il peut y en avoir plus. Les trois éléments ici sont des éléments d'entiers. Le premier a la valeur 14 ; le suivant a la valeur 88 ; et le dernier a la valeur 47. Chaque élément ici se compose de trois emplacements consécutifs.

Ceci est différent du tableau, où chaque élément est un emplacement, et tous les éléments du tableau sont dans des emplacements consécutifs. Ici, les différents éléments sont à des endroits différents dans la série de mémoire, mais chaque élément se compose de trois emplacements consécutifs.

Pour chaque élément, l'emplacement du milieu détient la valeur. Le bon emplacement a le pointeur vers l'élément suivant. L'emplacement de gauche a le pointeur vers l'élément précédent. Pour le dernier élément, le bon emplacement pointe vers une fin théorique de la liste. Pour le premier élément, l'emplacement de gauche pointe vers un début théorique de la liste.

Avec le tableau, l'opérateur d'incrémentation (++), incrémente le pointeur pour pointer physiquement vers l'emplacement suivant. Avec la liste, les éléments ne sont pas dans des régions consécutives en mémoire. Ainsi, l'opérateur d'incrémentation peut être surchargé, déplacez l'itérateur (pointeur) d'un élément à l'élément logiquement suivant. La même projection s'applique à l'opérateur de décrémentation (-).

Un itérateur avant est un itérateur qui, lorsqu'il est activé, pointe vers l'élément suivant. Un itérateur inverse est un itérateur qui, lorsqu'il est engagé, pointe vers l'élément précédent.

Surcharge ++ de l'annonce -

La surcharge de ces opérateurs se fait dans la description de classe (définition) de l'itérateur.

La syntaxe du prototype de la surcharge de l'opérateur d'incrémentation, préfixe, est

Opérateur ReturnType++();

La syntaxe du prototype de surcharge de l'opérateur d'incrémentation, postfix, est

Opérateur ReturnType++(int);

La syntaxe du prototype de la surcharge de l'opérateur de décrémentation, préfixe, est

Opérateur ReturnType--();

La syntaxe du prototype de surcharge de l'opérateur d'incrémentation, postfix, est

Opérateur ReturnType--(int);

Conclusion

Surcharger, c'est donner un sens différent à une fonction ou à un opérateur. Les fonctions sont surchargées dans le même périmètre. Ce qui différencie les fonctions surchargées, c'est le nombre et/ou les types de paramètres dans leurs listes de paramètres. Dans certains cas, où le nombre de paramètres est le même, mais avec des types différents, le compilateur rejette la surcharge - voir plus loin. De nombreux opérateurs ordinaires peuvent être surchargés dans les classes à partir desquelles les objets sont instanciés. Cela se fait en donnant un type de retour, une liste de paramètres et un corps, à la fonction spéciale nommée, opérateur, dans la description de la classe.