Surcharge en C ++

C ++ n'autorise pas une fonction qui ajoute deux entiers et renvoie un entier, pour ajouter deux flotteurs et renvoyer un flotteur. Imaginez qu'il existe une fonction pour ajouter deux entiers et retourner un entier. Ne serait-ce pas bien d'avoir une autre fonction avec le même nom, qui ajoute que deux ou même plus de flotteurs pour retourner un flotteur? Cela serait censé le faire, surcharger la première fonction.

Les opérateurs arithmétiques sont généralement utilisés pour les opérations arithmétiques. N'est-ce pas agréable d'avoir le +, rejoignez deux cordes? Permettant que cela surcharge l'opérateur d'addition arithmétique, pour les chaînes.

L'opérateur d'incrément, ++ ajoute 1 à un int ou un flotteur. Lorsque vous traitez avec des 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 liée, mais les objets de liste liée sont à différents endroits en mémoire (pas dans des régions consécutives). Ne serait-il pas agréable de surcharger l'opérateur d'incrément pour un itérateur, pour incrémenter mais pointer vers l'élément suivant, dans la liste liée?

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

Contenu de l'article

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

Surcharge de fonction

La fonction suivante ajoute deux INT et renvoie un int:

int add (int n ° 1, int n ° 2)

int sum = 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 flotteurs et rendrait un flotteur:

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

float sum = no1 + no2 + no3;
somme de retour;

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

int sm = add (2, 3);

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

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

appellerait la fonction flottante. Remarque: il y a 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
Utilisation de Namespace Std;
int add (int n ° 1, int n ° 2)

int sum = no1 + no2;
somme de retour;

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

float sum = no1 + no2 + no3;
somme de retour;

int main()

int sm = add (2, 3);
couter<float sme = ajouter (2.3, 3.4, 2.0);
couter<retour 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 classes. Un itérateur est un type de classe. Les opérateurs d'incrément et de décrément sont utilisés pour surcharger les opérations pour un itérateur.

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

Cette section fournit un exemple, où + est surchargé pour une classe de chaîne simplement conçue, appelée une classe de printemps. + concaténe les littéraux de deux objets à cordes, renvoyant un nouvel objet avec les littéraux concaténés. Conaténuer deux littéraux signifie rejoindre le deuxième littéral à la fin du premier littéral.

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

#inclure
Utilisation de Namespace Std;
printemps de classe

public:
// membres de données
Char Val [100];
int n;
Char Concat [100];
// Fonctions membres
printemps (char arr [])

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

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

Opérateur de printemps + (Spring & 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! "; Spring Str1 (CH1);
char ch2 [] = "mais elle vous aime!"; Spring Str2 (CH2);
char ch3 [] = "un"; Spring Str3 (CH3);
str3 = str1 + str2;
couter<retour 0;

La valeur de Str1 est "Je te déteste! ". La valeur de Str2 est "mais elle vous aime!". La valeur de STR3, qui est, STR1 + STR2, est la sortie:

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

qui est la concaténation des deux littéraux de cordes. Les cordes elles-mêmes sont des objets instanciés.

La définition de la fonction de l'opérateur se trouve à 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 des paramètres, qui est en fait la liste d'opérands. + est un opérateur binaire: ce qui signifie qu'il prend une gauche et un opérande droit. Cependant, par la spécification C ++, la liste des paramètres n'a ici que le bon paramètre. Ensuite, il y a le corps de la fonction de l'opérateur, qui imite le comportement de l'opérateur ordinaire.

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 + () concerne 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 cordes sont concaténés dans le tableau, Newstr []. Après cela, un nouvel objet String est réellement créé (instancié), en utilisant un argument, NewsTr []. À 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 est effectué par l'instruction:

str3 = str1 + str2;

Où STR1, STR2 et STR3 sont des objets de chaîne qui ont déjà été créés dans Main (). L'expression, «STR1 + STR2» avec son +, appelle la fonction membre de l'opérateur + () dans l'objet STR1. La fonction membre de l'opérateur + () 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 complète, remplace le contenu (valeurs des variables) de l'objet STR3, avec ceux de l'objet retourné. Dans la fonction principale (), après l'addition, la valeur du membre de données STR3.Val n'est plus "un"; C'est la chaîne concaténée (ajout), "Je te déteste! Mais elle t'aime!". La fonction de membre de l'opérateur + () dans l'objet STR1, utilise le littéral de la chaîne de son propre objet et la chaîne littérale de son argument, STR2 pour proposer une chaîne littérale jointe.

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

Lorsqu'ils traitent avec l'itérateur, au moins deux objets sont impliqués: une liste liée et l'itérateur lui-même. En fait, au moins deux classes sont impliquées: une classe dont une liste liée est instanciée et une classe dont un itérateur est instancié.

Liste liée

Un diagramme pour un objet de liste doublement lié est:

Cette liste a trois éléments, mais il peut y 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 endroit, et tous les éléments du tableau sont dans des emplacements consécutifs. Ici, les différents éléments sont à différents endroits de la série de mémoire, mais chaque élément se compose de trois emplacements consécutifs.

Pour chaque élément, l'emplacement central contient 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ément (++), incrémente le pointeur pour pointer vers l'emplacement physiquement 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ément peut être surchargé, déplacer 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ément (-).

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

Surcharge ++ annonce -

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

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

ReturnType Operator ++ ();

La syntaxe du prototype de la surcharge de l'opérateur d'incrément, Postfix, est

ReturnType Operator ++ (int);

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

RETROYALTYPE OPÉRATEUR - ();

La syntaxe du prototype de la surcharge de l'opérateur d'incrément, Postfix, est

RETROYALTYPE Opérateur - (INT);

Conclusion

La surcharge signifie donner une signification différente à une fonction ou à un opérateur. Les fonctions sont surchargées dans la même portée. Ce qui différencie les fonctions surchargées, ce sont 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 différents types, le compilateur rejette la surcharge - voir plus tard. De nombreux opérateurs ordinaires peuvent être surchargés dans des 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.