Surcharge d'opérateurs, un conflit !

Version imprimable

Bonsoir :mrgreen:,

J'ai un problème de compilation à cause de surcharges d'opérateurs.

J'ai une class qui s'appelle Eleve

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
class Eleve
{
      private:
                 char *nom;
                 int numero;
      public:
                 des constructeurs...
 
              const Eleve & operator = (const Eleve &);  //Entre deux Eleve
              const char* & operator = (const Eleve &); //Entre char* et Eleve
}

Voilà le code des deux fonctions :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
//Concerne deux Eleves
const Eleve & Eleve ::operator = (const Eleve  &e)
{
	if (this != &e)
	{
		this->nom = strdup(e.nom);
                rhis->numero = e.numero;
	}
	return *this;
}
 
//cette fonction concerne une variable char* avec Eleve
const char* & Eleve ::operator = (const Eleve &e)
{
	return e.nom;
}

Dans mon main, j'aimerai effectuer ces deux opérations :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
int main()
{
    Eleve E1("Patrick",1);   //ici pas de problème
    Eleve E2;                      //ici pas de problème
    string nom;
 
    E2 = E1;                //1er surcharge d'opérateur =
 
    nom = E2;             // 2ème surcharge d'opérateur =, ici je voudrai affecter le nom de E2 à la variable "nom" !!
return 0;
}

Avec la compilation ça ne marche pas, voilà l'erreur :

Code:

1
2
3
4
5
6
 
Erreur	1	error C2556: 'const char *&Eleve::operator =(const Eleve &)' : la fonction surchargée ne diffère que par le type de retour de 'const Eleve &Eleve::operator =(const Eleve &)'	c:\users\sean\desktop\exam c++\exam\exam\eleve.h	23
Erreur	3	error C2556: 'const char *&Eleve::operator =(const Eleve &)' : la fonction surchargée ne diffère que par le type de retour de 'const Eleve &Eleve::operator =(const Eleve &)'	c:\users\sean\desktop\exam c++\exam\exam\eleve.cpp	34
Erreur	2	error C2373: 'Eleve::operator =' : redéfinition ; modificateurs de type différents	c:\users\sean\desktop\exam c++\exam\exam\eleve.h	23
Erreur	4	error C2373: 'Eleve::operator =' : redéfinition ; modificateurs de type différents	c:\users\sean\desktop\exam c++\exam\exam\eleve.cpp	34
Erreur	5	error C2084: la fonction 'const Eleve &Eleve::operator =(const Eleve &)' a déjà un corps	c:\users\sean\desktop\exam c++\exam\exam\eleve.cpp	34

Merci de m'aider:mrgreen:. si mon code est illisible, je voudrai simplement savoir comment implementer deux surcharges d'opérateurs (=) en meme temps en:
1) le premier avec deux classes.
2) le deuxième avec deux type différents (comme le cas de Nom=E1)

merci !

Salut,

D'une façon générale, deux surcharges ne peuvent varier que par leur type retour. Ce qui explique ton erreur puisque la première et la seconde surcharge ne diffèrent que sur le type retour.

Ensuite, l'opérateur '=' dans l'expression A=B; s'applique à l'objet A et concerne donc la classe A. Ainsi dans ton code : nom = E2; il s'agit d'un opérateur '=' de la classe std::string. Arf ! Comme tu ne peux définir un opérateur '=' à la classe std::string (car l'opérateur '=' ne peux être définis comme fonction libre) c'est qu'il ne s'agit probablement pas du bon choix. Tu devrais regarder du côté d'un opérateur de transtypage pour ton exercice : operator char const *() const.

Pour répondre à tes questions :
Code:

1 2 3 4 5 6 7 8 9 10 11 class Eleve { private: std::string nom; int numero; public: const Eleve & operator = (const Eleve &); // 1 const Eleve & operator = (std::string const &); // 2 operator std::string() const; // 3 };
Avec l'utilisation :
Code:

1 2 3 4 5 6 7 Eleve E1("Patrick",1); Eleve E2; std::string nom; E2 = E1; // (1) E1 = nom; // (2) nom = E2; // (3)
Pour l'écriture d'un opérateur =, tu peux regarder du côté de la F.A.Q.

13/12/2010, 07h27
Joel F

L'operateur d etranstypage est souvent une mauvaise idée. Ca crée des effets parfois compliqués à retrouver. Une forme plus générique est de passer par une fonction d'adaptation qui explicite la transformation.
13/12/2010, 07h29
3DArchi

Citation:

Envoyé par Joel F

L'operateur d etranstypage est souvent une mauvaise idée. Ca crée des effets parfois compliqués à retrouver. Une forme plus générique est de passer par une fonction d'adaptation qui explicite la transformation.

Ouaip. Quoiqu'avec explicit de C++0x ça évite les surprises.
Cependant, ici, cela sent l'exercice à plein nez.