Probleme avec operator<

Voila, j'ai des templates qui m'ont été fournis pour m'aider a faire un programme, mais je cherche a rajouter quelques trucs qui moanquent. Ici en l'occurence c'est un opérateur de comparaison <

De plus je crois que j'suis completement en train de me pommer dans les patrons parce que j'ai des trucs du genre CTArbre <CTNoeud <STNoeud> >. Jai fait des operateurs dans CTNoeud et STNoeud et j'arrive pas a comprendre les erreur du compilateur :

Code:

---

'bool CTNoeud<T>::operator< (const CTNoeud<T>&, const CTNoeud<T>&)' must take exactly one argument

---

Ce que je comprend c'est qu'il faut qu'un argument pour l'operateur <, mais la je comprends plus parce que je vois pas comment comparer 2 trucs en en prenant qu'un seul :cry: j'en ai beaucoup dans ce genre et je sais pas quoi faire

si quelqu'un a une idée, merci

(si y a besoin que je poste des parties des classes ou autre, demandez, c'est juste que j'avais pas envie d'encombrer inutilement)

Le prototype d'un opérateur binaire @ pour Ta @ Tb est soit
Tr operator @ ( Ta, Tb );
soit
Tr Ta::operator @ ( Tb );

Mais certainement pas
Tr Ta::operator @ ( Ta, Tb );

Voià ;-).

ok alors faut que j'utilise celle la :

Tr Ta::operator @ ( Tb );

mais dans ce cas la comment on effectue la comparaison entre Ta et Tb, vu que Ta c'est juste le nom de la class, c'est pas une instance?

la par exemple je peux pas mettre :

Code:

---

{ return (Ta < Tb) }

---

bah nan pourtant c'est bien Tr operator @ ( Ta, Tb ); qu'il faut que je mette, mais quand j'ecrit dans le patron ça :

Code:

---

bool operator < (const CTNoeud<T>& noeud1, const CTNoeud<T>& noeud2)

---

l'erreur est toujours celle la :

Code:

---

'bool CTNoeud<T>::operator< (const CTNoeud<T>&, const CTNoeud<T>&)' must take exactly one argument

---

Citation:

---

Envoyé par Sokar

pourtant c'est bien Tr operator @ ( Ta, Tb ); qu'il faut que je mette

---

Alors ta fonction ne doit pas être une fonction membre, elle doit être en dehors de la classe. Puis, comme elle devra probablement accéder aux membres privés de la classe, ce sera une amie (friend) de cette classe.

L'autre choix est d'en faire une fonction membre, mais dans ce cas elle ne prend qu'un seul paramètre. Dans ce cas, la comparaison se fait entre l'objet lui-même et celui donné en paramètre.

bin a priori j'ai plus l'erreur, maintenant c'est des comme ça qui me pose probleme :

Code:

---

1 2 3

CTArbre.h: no match for 'const CTNoeud<STNoeud>& < CTNoeud<STNoeud>&' STNoeud.h: candidates are : bool operator<(const STNoeud&, const STNoeud&) STNoeud.h: bool operator<(const SYNoeud&, const STNoeud&)

---

pourtant j'ai fait un operateur < pout CTNoeud et un pour STNoeud, je sais pas ce qu'il faut faire...

Tu peux nous montrer le code correspondant à tout ça ?

oui pas de probleme

ô_O alors je commence par la partie du main qui fait appel aux operateurs :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

typedef CTArbre <CTNoeud <STNoeud> > Arbre;   Arbre* arbre = new Arbre(); STNoeud stnoeud;   ...   istringstream iss(chaine); while(iss >> mot) { stnoeud.mot = mot; CTNoeud<STNoeud> ctnoeud(stnoeud); ctnoeud.Insere(stnoeud); arbre->Insere(ctnoeud); }

---

ensuite y a le Insere de CTNoeud :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

template <typename T> CTNoeud <T> *CTNoeud <T>::Insere (const T &t) {   CTNoeud <T> *pere, *pnouv;   // cas particulier : arbre vide if (this == NULL) { pnouv = new CTNoeud <T> (t); return pnouv; } // autres cas : on recherche le père du nouveau noeud pere = RechPere (this, t); // ce noeud est ajouté à l'arbre s'il n'est pas encore présent if (t != pere->mInfo) { pnouv = new CTNoeud <T> (t); if (t > pere->mInfo) pere->mFd = pnouv; else pere->mFg = pnouv;   return this; } // noeud déjà présent return this;   } // Insere

---

et le insere de CTArbre :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

template <typename T> void CTArbre <T>::Insere (const T &t) {   // cour est la racine du sous arbre courant // pere est l'adresse de l'ascendant de cour CTNoeud <T> *cour = mRacine, *pere = NULL, *nouveau;   // recherche du père du noeud à insérer // qui doit être une feuille while (cour != NULL) { // mémorisation adresse père pere = cour; // poursuite recherche en tenant compte de la relation d'ordre if (t < cour->mInfo) cour = cour->mFg; else cour = cour->mFd; }   // initialisation nouveau noeud (c'est une feuille) nouveau = NouvNoeud (t, NULL, NULL);   // si père == NULL, le nouveau noeud est la racine if (pere == NULL) mRacine = nouveau; // recherche du sous arbre de rattachement de t // l'arbre reste ordonné pour un parcours infixe else if (t < pere->mInfo) pere->mFg = nouveau; else pere->mFd = nouveau;   // le nouveau noeud devient le noeud courant mCourant = nouveau; mTaille++;   } // Insere

---

De la arrive les probleme, les operateurs, j'ai fait les operateurs dans CTNoeud et dans STNoeud pour que les fonctions Insere de CTArbre et CTNoeud puissent fonctionner, donc ça donne ça :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

// STNoeud.h   class STNoeud {   public: string mot; CTListe<CTElem <int> > liste;   public: friend bool operator!= (const STNoeud& noeud1, const STNoeud& noeud2); friend bool operator< (const STNoeud& noeud1, const STNoeud& noeud2); friend bool operator> (const STNoeud& noeud1, const STNoeud& noeud2);   };   // === Opérateurs   bool operator!= (const STNoeud& noeud1, const STNoeud& noeud2) { return (noeud1.mot != noeud2.mot); }   bool operator< (const STNoeud& noeud1, const STNoeud& noeud2) { return (noeud1.mot < noeud2.mot); }   bool operator> (const STNoeud& noeud1, const STNoeud& noeud2) { return (noeud1.mot > noeud2.mot); }

---

celui de CTNoeud je l'ai pis dans un cpp et pas dans le .h :

Code:

---

1 2 3 4 5 6 7

friend bool operator < (const CTNoeud<T>& noeud1, const CTNoeud<T>& noeud2); //===============================================// template <typename T> bool operator < (const CTNoeud<T>& noeud1, const CTNoeud<T>& noeud2)   { return (noeud1.mInfo < noeud2.mInfo); }

---

:?: :?: :?:

Citation:

---

celui de CTNoeud je l'ai pis dans un cpp et pas dans le .h

---

:D

http://c.developpez.com/faq/cpp/?pag...VERS_templates

oui mais si je le met dans le .h j'arrive pas a le faire marcher non plus, ça me met l'erreuer :

Code:

---

'bool CTNoeud<T>::operator< (const CTNoeud<T>&, const CTNoeud<T>&)' must take exactly one argument

---

surement que ma yntaxe est fausse mais je sais pas comment l'ecrire

Attention, il y a une différence entre mettre dans le .h et mettre dans la classe. Ton code précédent nous montre un opérateur < non-membre, mais d'après le message d'erreur c'est bien une fonction membre. Alors quand tu dis "le mettre dans le .h" est-ce que tu ne le mets pas en fait en tant que membre de ta classe ?

euhh je sais pas, c'est quoi qu'il faut que je fasse ?

en effet j'ai du mettre l'operateur en tant que fonction memebre mais dans ce cas la comme la mettre en fonctionnon membre tout en la laissant dans le .h?

en fait il faut que je le fasse comment mon operateur<?

Solution 1 : non-membre

Code:

---

1 2 3 4 5 6 7 8 9

template <class T> class CTNoeud { template <class U> friend bool operator < (const CTNoeud<U>&, const CTNoeud<U>&); };   template <class T> bool operator < (const CTNoeud<U>& n1, const CTNoeud<U>& n2) { ... }

---

Solution 2 : membre

Code:

---

1 2 3 4 5 6 7 8 9

template <class T> class CTNoeud { bool operator < (const CTNoeud<T>&); };   template <class T> bool CTNoeud<T>::operator < (const CTNoeud<T>& n) { ... }

---

j'prefere la solution 1

mais ça je dois le mettre dans quelle fichier? et aussi est ce que c'est normal que y ai des <class U> et des <class T>?

Tu devrais relire un coup la section concernant les templates dans la FAQ C++, et essayer de comprendre pourquoi on procède comme ça (pour l'organisation des fichiers et la syntaxe). Sinon tu ne vas pas t'en sortir :wink:

ok j'vais faire ça lol