Dans cette page je décris les nouveautés du c++, en matière de fonctions et d'opérateurs.

Le langage c++ permet de déclarer, des fonctions de même nom, dans la mesure où leurs arguments sont significativement différents.

Par exemple, si le nombre ou le type des arguments de deux fonctions de même nom, sont différents, le compilateur leur affecte une référence différente. Elles sont donc reconnues comme des fonctions distinctes.

On peut, par exemple, déclarer plusieurs constructeurs d'une classe, en rappelant que le nom d'un constructeur, doit être obligatoirement le nom de la classe. Ceci est très utile pour particulariser des sous-ensembles d'objets d'une même classe.

On peut par exemple introduire un constructeur pour les réels, et un constructeur pour les complèxes, en particularisant les réls de la classe complexe, comme les complèxes dont la partie imaginaire est nulle. Ces constructeurs seront déclarés comme :

complexe(fload r) ; complexe(float r,float i) ;

Comme le nombre d'arguments de ces 2 fonctions membre sont différents, le compilateur les reconnaîtra comme 2 constructeurs distincts.

On utilise le terme overread, pour désigner de telles fonctions. On peut de même définir de nouveaux opérateurs, à partir de presque tous les opérateurs existants, en les surchargeant (de l'anglais overloading)

Un opérateur surchargé est déclaré comme un membre public d'une classe, et peut être utilisé dans les programmes, comme on le fait avec un opérateur ordinaire. On peut surcharger les opérateurs unaires, ou binaires, à l'exception du . (point ou sélecteur de membre) de .* (point étoile déréférence)) et ->* (flèche étoile déréférence de pointeur de membre)

Par exemple, dans la classe complexe, on peut introduire l'opérateur surchargé +, qui effectuera l'addition de 2 nombres complexes, en écrivant le code suivant :

class complexe { float r ; float i ; public : complexe(float) ; complexe(float , float); complexe operator + (complexe) ; } ;

L'implémentation des membres s'écrira :

complexe :: complexe(float re) { r = re ; i = 0 ; } complexe :: complexe (float re, float ima) { r = re ; i = ima ; } complexe::complexe operator + (complexe c) { complexe c1 ; c1.r = r + c.r ; c1.i = i + c.i ; return c1 ; }

Dans le programme, on utilisera l'opérateur + surchargé, comme on le ferait avec l'opérateur ordinaire. Par exemple :

complexe c1(1,0) ; complexe c2(0,1) ; complexe c = c1 + c2 ;

On peut aussi écrire :

complexe c = c1.operator + (c2) ; puisque la fonction operator + est un membre de la classe complexe.

On a déja signalé dans le cours 1, l'intéret des opérateurs unaires surchargés <<, >> (décalage binaire à gauche et à droite) dans la classe iostream

Vous pouvez ajouter d'autres surcharges de ces opérateurs, pour des entrées formatées dans vos classes.

Consultez les 2 liens suivants, pour un récapitulatif des opérateurs du c et du c++, ainsi que pour des exemples d'opérateurs surchargés.

operator.cpp : les opérateurs du c et du c++

operateu.cpp : exemple d'opérateurs surchargés

Je termine cette page, par l'instruction friend, qui permet de déclarer des fonctions amies d'une classe. La syntaxe d'une fonction membre amie est :

friend type mafon(...) ; ou type est le type renvoyé par mafon

Une fonction amie d'une classe, est accessible aux classes dérivées de la classe de base, pour laquelle elles ont été déclarées amies.

La déclaration friend peut être placée n'importe où dans la classe, et ne dépend pas des déclarations public private ou protected.

L'exemple du lien suivant, reprend la source class2.cpp, en lui ajoutant une fonction amie.

class3.cpp : exemple d'une fonction amie d'une classe

Vous trouverez des exemples d'utilisation des fonctions amies, dans le cours 5 sur l'héritage et sur l'héritage multiple.

suivant : cours 5 les classes dérivées (héritage et héritage multiple) retour au sommaire du cours cpptutor