Discussion :

[Sokar]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

'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 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)

[Selenite]

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à ;-).

[Sokar]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

{ return (Ta < Tb) }

[Sokar]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

l'erreur est toujours celle la :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[axile]

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.

[Sokar]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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...

[Laurent Gomila]

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

[Sokar]

oui pas de probleme

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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); }

: : :

[Laurent Gomila]

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

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

[Sokar]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

'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

[Laurent Gomila]

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 ?

[Sokar]

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<?

[Laurent Gomila]

Solution 1 : non-membre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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)
{
    ...
}

[Sokar]

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>?

[Laurent Gomila]

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

[Sokar]

ok j'vais faire ça lol