Surcharge d'opérateurs [Résolu]

Messages postés
123
Date d'inscription
vendredi 14 novembre 2008
Statut
Membre
Dernière intervention
18 juin 2012
- - Dernière réponse : dyroj
Messages postés
123
Date d'inscription
vendredi 14 novembre 2008
Statut
Membre
Dernière intervention
18 juin 2012
- 25 oct. 2010 à 11:08
Bonjour,

En apprenant un cour sur le langage c++ je suis arriver au surcharge d'opérateurs. Je pence avoir compris le fonctionnement mais il y a quelque chose qui me dérange, c'est la référence utiliser dans la fonction :
Objet operator+(const Objet &monObjet);
Donc ma question est la suivante, pourquoi utiliser une référence en l'occurrence &monObjet et pas un simple objet par exemple :
Objet operator+(const Objet monObjet);
J'ai d’ailleurs testé et cela fonctionne normalement.

Au revoir.
Afficher la suite 

6 réponses

Meilleure réponse
Messages postés
3838
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
10 juin 2019
84
3
Merci
Mon exemple t'expliquais la passage par référence et non la constitude.

Quand on veut passer par référence, on prend le risque de voir sa variable être modifié. Donc on passe par copie pour éviter cela.
Parfois (et même souvent), passer par copie peut être très couteux en performance.

Donc on se retrouve avec le dilemme: performance/sécurité.

Le "const truc&" permet d'avoir le beurre et l'argent du beurre. Non seulement on va pouvoir passer par référence (et donc éviter une couteuse copie) mais en plus, grâce au "const", on est sur que la variable ne sera pas modifiée par l'appel à la fonction.

C'est extrêmement utilisé en C++.

Ex:
// copie inutile de str
void affiche(std::string str)
{
  std::cout << str << std::endl;
}

// const est ici inutile, puisque str est passé de tout façon par copie.
// + copie inutile de str
void affiche(const std::string str)
{
  std::cout << str << std::endl;
}

// Ici, pas de copie. Mais on prend le risque de voir str être modifié.
void affiche(std::string& str)
{
  str = "toto"; // str peut être modifié. Or pour une fonction d'affichage, ça devrait être impossible
  std::cout << str << std::endl;
}

// Version parfaite :). Pas de copie inutile, pas de risque de modification de str
void affiche(const std::string& str)
{
  std::cout << str << std::endl;
}


________________________________________________________________________
Historique de mes créations, et quelques articles:
[ http://0217021.free.fr/portfolio http://0217021.free.fr/portfolio]
Merci d'utiliser Réponse acceptée si un post répond à votre question

Dire « Merci » 3

Quelques mots de remerciements seront grandement appréciés. Ajouter un commentaire

Codes Sources 131 internautes nous ont dit merci ce mois-ci

Commenter la réponse de cptpingu
Messages postés
3838
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
10 juin 2019
84
0
Merci
Utiliser une référence évite la copie inutile de l'objet :)
(Gain de performance)

________________________________________________________________________
Historique de mes créations, et quelques articles:
[ http://0217021.free.fr/portfolio http://0217021.free.fr/portfolio]
Merci d'utiliser Réponse acceptée si un post répond à votre question
Commenter la réponse de cptpingu
Messages postés
123
Date d'inscription
vendredi 14 novembre 2008
Statut
Membre
Dernière intervention
18 juin 2012
0
Merci
Ha OK mais c'est quoi la différence entre une copie et une référence? Sa a un rapport avec la mémoire ou autre?
Commenter la réponse de dyroj
Messages postés
3838
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
10 juin 2019
84
0
Merci
Exemple:

void swap(int a, int b)
{
  int tmp = a;
  a = b;
  b = tmp;
}


Ce code passe a et b par copie. Donc a et b seront échangé localement. Ce ne sont pas les valeurs directement.
Donc si tu fais:
int x = 5;
int y = 8;
swap(x, y);
std::cout << x << " " << y << std::endl;


x et y ne seront pas inversé. Car une copie de x et de y, ont été inversé.

Alors qu'avec ce code, tout fonctionnera bien:
void swap(int& a, int& b)
{
  int tmp = a;
  a = b;
  b = tmp;
}


Si tu ne comprends pas pourquoi ça fonctionne, c'est que tu maîtrise vraisemblablement mal les pointeurs et la mémoire.
Je t'invite à bien approfondir ce sujet, en faisant par exemple du C, avant de te mettre au C++.

________________________________________________________________________
Historique de mes créations, et quelques articles:
[ http://0217021.free.fr/portfolio http://0217021.free.fr/portfolio]
Merci d'utiliser Réponse acceptée si un post répond à votre question
Commenter la réponse de cptpingu
Messages postés
123
Date d'inscription
vendredi 14 novembre 2008
Statut
Membre
Dernière intervention
18 juin 2012
0
Merci
Sauf que dans la fonction opérateur on ne modifi pas la référence car c'est une constante :
Objet operator+(const Objet &monObjet);
et donc :
void swap(const int& a,const int& b)
{
int tmp = a;
a = b;
b = tmp;
}

Erreur de compilation.
Commenter la réponse de dyroj
Messages postés
123
Date d'inscription
vendredi 14 novembre 2008
Statut
Membre
Dernière intervention
18 juin 2012
0
Merci
OK je te remercie pour ton aide.
Au revoir.
Commenter la réponse de dyroj