1 bool operator pour 2 type differents.

Fermé
martom - 29 déc. 2009 à 22:34
loupius Messages postés 697 Date d'inscription dimanche 1 novembre 2009 Statut Membre Dernière intervention 31 décembre 2017 - 30 déc. 2009 à 23:18
Bonjour,

D'avance merci aux patients lecteurs :)

Voici mon problème :


J'ai une classe étudiant qui hérite de la classe personne.

Lors de l'utilisation de la fonction find, j'ai besoin de comparer le nom ET le sexe de 2 étudiants.

J'ai cette erreur lors de la compilation : error C2678: binary '==' : no operator found which takes a left-hand operand of type 'etudiant' (or there is no acceptable conversion)

Je crois comprendre qu'il ne trouve pas d'opérateur qui compare, en + du nom, un char (ici le sexe (M/F))
Comment régler/contourner ce problème ?


MON CODE :

class personne{

	string nom;
public :
	void saisie();
	void aff();	
	string get_nom();
};

class etudiant:public personne{

	int notes[2];
	char sexe;
public : 
	void saisie();
	void aff();
	char get_sexe();
	int get_notes(int i);

	bool operator==(etudiant a){
		if(get_nom()==a.get_nom()){

			if(sexe==a.sexe)
			return(1);
			else
				return(0);
		}
		else
			return(0);
	}
};


Merci pour votre aide
A voir également:

7 réponses

Pacorabanix Messages postés 3248 Date d'inscription jeudi 23 août 2007 Statut Membre Dernière intervention 19 mai 2013 661
29 déc. 2009 à 22:49
il se peut que je dise une bêtise, mais ne devrais-tu pas donner deux paramètres à ta fonciton operator== ( ) ?
0
loupius Messages postés 697 Date d'inscription dimanche 1 novembre 2009 Statut Membre Dernière intervention 31 décembre 2017 148
30 déc. 2009 à 01:58
Personnellement je ne vois pas d'erreur dans la définition de la fonction 'operator=='; peut-être faut-il chercher là où elle est appellée. Il faudra bien sûr définir les fonctions qui sont déclarées dans les classes.
Par contre, je n'aime pas beaucoup la style de la fonction 'operateur', j'aurais plutôt écrit (plus simple et plus efficace) :
bool operator== (etudiant a)
{
  if ( (get_nom() == a.get_nom() && (sexe == a.sexe) )
    return(1);
  return(0);
}
et même plus simple:
bool operator== (etudiant a)
{
  return ( (get_nom() == a.get_nom() && (sexe == a.sexe) );
}
Bonne continuation.
0
Oui au début j'avais fais comment tu le suggère Loupius, mais j'ai changé en pensant qu'il y avait peut-être une erreur de distraction que je n'arrivais pas à voir..

Pourquoi devrais donner 2 paramètres Pacorabanix ? Je compare le nom d'un ÉTUDIANT et son sexe, mais le paramètre passé est un étudiant non ?
0
loupius Messages postés 697 Date d'inscription dimanche 1 novembre 2009 Statut Membre Dernière intervention 31 décembre 2017 148
30 déc. 2009 à 10:42
On doit effectivement se poser la question: doit-on passer 1 ou 2 paramètres ?
Si les deux paramètres de l'opération sont du type de la classe, on déclare la fonction 'operator' comme fonction membre avec un seul paramètre; par contre si l'un des deux paramètres n'est pas du type de la classe, alors il faut déclarer la fonction 'operator' comme fonction globale avec deux paramètres.
Ici, on préfère en général appliquer le premier cas (c'est plus simple), mais on peut aussi appliquer le second.
Tu ne dis pas si ton problème est résolu ?
Bonne continuation.
0

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question
Non mon problème n'est toujours pas résolu..

Quelqu'un peut m'aider ?

Merci....
0
loupius Messages postés 697 Date d'inscription dimanche 1 novembre 2009 Statut Membre Dernière intervention 31 décembre 2017 148
30 déc. 2009 à 22:11
Et quelles sont les lignes qui font appel à l'opérateur '==' ?
0
C'est dans algorithm même :

// TEMPLATE FUNCTION find
template<class _InIt,
	class _Ty> inline
	_InIt _Find(_InIt _First, _InIt _Last, const _Ty& _Val)
	{	// find first matching _Val
	for (; _First != _Last; ++_First)
		if (*_First == _Val)             <------ a Cette ligne-ci
			break;
	return (_First);
	}


Et voici toute la description de l'erreur :

error C2678: binary '==' : no operator found which takes a left-hand operand of type 'etudiant' (or there is no acceptable conversion)
1>          c:\program files\microsoft visual studio 10.0\vc\include\exception(470): could be 'bool std::operator ==(const std::_Exception_ptr &,const std::_Exception_ptr &)'
1>          c:\program files\microsoft visual studio 10.0\vc\include\exception(475): or       'bool std::operator ==(std::_Null_type,const std::_Exception_ptr &)'
1>          c:\program files\microsoft visual studio 10.0\vc\include\exception(481): or       'bool std::operator ==(const std::_Exception_ptr &,std::_Null_type)'
1>          c:\program files\microsoft visual studio 10.0\vc\include\system_error(416): or       'bool std::operator ==(const std::error_code &,const std::error_condition &)'
1>          c:\program files\microsoft visual studio 10.0\vc\include\system_error(424): or       'bool std::operator ==(const std::error_condition &,const std::error_code &)'
1>          c:\temp\2eme bach\examen preparation\janvier 2008 b\janvier 2008 b\index.cpp(32): or       'bool etudiant::operator ==(etudiant)'
1>          while trying to match the argument list '(etudiant, const std::string)'
1>          c:\program files\microsoft visual studio 10.0\vc\include\algorithm(74) : see reference to function template instantiation '_InIt std::_Find<std::_List_unchecked_iterator<_Mylist>,_Ty>(_InIt,_InIt,const _Ty &)' being compiled
1>          with
1>          [
1>              _InIt=std::_List_unchecked_iterator<std::_List_val<etudiant,std::allocator<etudiant>>>,
1>              _Mylist=std::_List_val<etudiant,std::allocator<etudiant>>,
1>              _Ty=std::string
1>          ]
1>          c:\temp\2eme bach\examen preparation\janvier 2008 b\janvier 2008 b\index.cpp(179) : see reference to function template instantiation '_InIt std::find<std::_List_iterator<_Mylist>,T2>(_InIt,_InIt,const _Ty &)' being compiled
1>          with
1>          [
1>              _InIt=std::_List_iterator<std::_List_val<etudiant,std::allocator<etudiant>>>,
1>              _Mylist=std::_List_val<etudiant,std::allocator<etudiant>>,
1>              T2=std::string,
1>              _Ty=std::string
1>          ]
1>          c:\temp\2eme bach\examen preparation\janvier 2008 b\janvier 2008 b\index.cpp(195) : see reference to function template instantiation 'void chercher<std::list<_Ty>,std::string>(T,T2)' being compiled
1>          with
1>          [
1>              _Ty=etudiant,
1>              T=std::list<etudiant>,
1>              T2=std::string
1>          ]
1>c:\program files\microsoft visual studio 10.0\vc\include\algorithm(41): error C2678: binary '==' : no operator found which takes a left-hand operand of type 'etudiant' (or there is no acceptable conversion)
1>          c:\program files\microsoft visual studio 10.0\vc\include\exception(470): could be 'bool std::operator ==(const std::_Exception_ptr &,const std::_Exception_ptr &)'
1>          c:\program files\microsoft visual studio 10.0\vc\include\exception(475): or       'bool std::operator ==(std::_Null_type,const std::_Exception_ptr &)'
1>          c:\program files\microsoft visual studio 10.0\vc\include\exception(481): or       'bool std::operator ==(const std::_Exception_ptr &,std::_Null_type)'
1>          c:\program files\microsoft visual studio 10.0\vc\include\system_error(416): or       'bool std::operator ==(const std::error_code &,const std::error_condition &)'
1>          c:\program files\microsoft visual studio 10.0\vc\include\system_error(424): or       'bool std::operator ==(const std::error_condition &,const std::error_code &)'
1>          c:\temp\2eme bach\examen preparation\janvier 2008 b\janvier 2008 b\index.cpp(32): or       'bool etudiant::operator ==(etudiant)'
1>          while trying to match the argument list '(etudiant, const std::string)'
1>          c:\program files\microsoft visual studio 10.0\vc\include\algorithm(74) : see reference to function template instantiation '_InIt std::_Find<etudiant*,_Ty>(_InIt,_InIt,const _Ty &)' being compiled
1>          with
1>          [
1>              _InIt=etudiant *,
1>              _Ty=std::string
1>          ]
1>          c:\temp\2eme bach\examen preparation\janvier 2008 b\janvier 2008 b\index.cpp(179) : see reference to function template instantiation '_InIt std::find<std::_Vector_iterator<_Myvec>,T2>(_InIt,_InIt,const _Ty &)' being compiled
1>          with
1>          [
1>              _InIt=std::_Vector_iterator<std::_Vector_val<etudiant,std::allocator<etudiant>>>,
1>              _Myvec=std::_Vector_val<etudiant,std::allocator<etudiant>>,
1>              T2=std::string,
1>              _Ty=std::string
1>          ]
1>          c:\temp\2eme bach\examen preparation\janvier 2008 b\janvier 2008 b\index.cpp(204) : see reference to function template instantiation 'void chercher<std::vector<_Ty>,std::string>(T,T2)' being compiled
1>          with
1>          [
1>              _Ty=etudiant,
1>              T=std::vector<etudiant>,
1>              T2=std::string
1>          ]
0
loupius Messages postés 697 Date d'inscription dimanche 1 novembre 2009 Statut Membre Dernière intervention 31 décembre 2017 148
30 déc. 2009 à 22:58
template<class _InIt, class _Ty> inline
...
if (*_First == _Val)

Donc '_First' est de type 'class _Init' et '_Val' de type 'class _Ty'; or j'ai précédemment écrit:
Si les deux paramètres de l'opération sont du type de la classe, on déclare la fonction 'operator' comme fonction membre avec un seul paramètre; par contre si l'un des deux paramètres n'est pas du type de la classe, alors il faut déclarer la fonction 'operator' comme fonction globale avec deux paramètres. On se trouve dans le deuxième cas et ta fonction 'operator==' ne peut correspondre.
Tu peux encore utiliser le premier cas en déclarant un constructeur de transtypage de la classe correspondant à '_Ty' vers la classe 'etudiant'.
Bonne réflexion.
0
loupius Messages postés 697 Date d'inscription dimanche 1 novembre 2009 Statut Membre Dernière intervention 31 décembre 2017 148 > loupius Messages postés 697 Date d'inscription dimanche 1 novembre 2009 Statut Membre Dernière intervention 31 décembre 2017
30 déc. 2009 à 23:18
Tu peux encore utiliser le premier cas en déclarant un constructeur de transtypage de la classe correspondant à '_Ty' vers la classe 'etudiant'.
A la réflexion, je ne pense pas que l'on puisse. Il faut impérativement utiliser le deuxième cas (fonction globale); mais utiliser alors un constructeur de transtypage (ou plusieurs) permet de ne déclarer qu'une seule fonction globale quelquesoit le type de l'autre opérande.
0
il faut déclarer la fonction 'operator' comme fonction globale avec deux paramètres.

Je ne comprend pas bien, et je ne trouve pas plus d'infos sur le net..

Je dois donc déclarer ma fonction operator comme une autre fonction ? Si c'est cela, après, comment faire pour indiquer a find d'utiliser cette operator là (lui passer en 3eme paramètre ?))

Si ce n'est pas ça du tout, merci de m'éclairer :)

PS : Dans un autre contexte, j'aurais cherché toute la nuit pour trouver tout seul mais je n'ai malheureusement pas le temps ! Je suis en blocus et chaque heure gagnée compte ;).... Et puis à un rythme de 9 à 12h de travail par jour, j'en ai un peu marre de cherché partout pour tout les cours :P
0