Discussion :

[Florian Goo]

Ben nan, le monsieur il a dit qu'il pouvait pas changer les char*…

[poukill]

Ahh c'est beau un code tout propre prêt à l'emploi pour le Posteur...

[stof]

Bonjour,

Merci à tous; je vais regarder ça.

[stof]

Bon, et bien c'est nickel.
Non seulement ça me sert mais ça servira aux autres qui tomberont sur ce post (y compris la "bonne méthode" C++ de koala01 qui ne me sert pas ici mais qui est mieux quand on part de rien).

par contre:

1°/ je m'interroge sur les

Code :

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

bool operator()(const  Cmyclass& t1, const Cmyclass& t2)

error C2662: : cannot convert 'this' pointer from 'const class Cmyclass' to 'class Cmyclass &'

Donc j'ai retiré les "const" et ça marche mais j'aurais bien aimé comprendre.

2°/Pour aller plus loin : j'ai 2 tableaux à trier quasiment de la même façon sauf qu'ils ne sont pas de la même classe.
Alors bêtement (?) j'ai dupliqué la fonction test()

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
struct test_1
{
	bool operator()(Cmyclass1& t1, Cmyclass1& t2)
	{ 
...
	}
};
 
struct test_2
{
	bool operator()(Cmyclass2& t1, Cmyclass2& t2)
	{ 
...
	}
};

Y a-t-il une façon plus intelligente ?

[Florian Goo]

Utilise un template de fonction !

@tous> D'ailleurs, pourquoi lui avoir fait utiliser un foncteur plutôt qu'une fonction ?

[poukill]

Parce que les algos générique de la STL font appel à l'opérateur ()...
Si tu veux utiliser un conteneur (map, list) avec un critère personnalisé, tu vas devoir écrire un foncteur...
D'ailleurs, un foncteur est par définition une classe avec l'operator () défini!

EDIT : au fait, le const sert à indiquer au compilo que tu ne modifie pas la valeur. Quand ce n'est pas le cas, il ne faut pas en mettre...

[yan]

@tous> D'ailleurs, pourquoi lui avoir fait utiliser un foncteur plutôt qu'une fonction ?

De ce que j'ai compris,
le foncteur aide les compilateurs à mieux optimiser le code généré .

Mais je ne l'affirme pas et ce n'est peut être plus vrai de nos jours.

[HanLee]

Parce que les algos générique de la STL font appel à l'opérateur ()...
Si tu veux utiliser un conteneur (map, list) avec un critère personnalisé, tu vas devoir écrire un foncteur...
D'ailleurs, un foncteur est par définition une classe avec l'operator () défini!

Non, les algo génériques de la STL ont besoin d'une variable d'un type qui permet d'utiliser l'opérateur ().
Ainsi les fonctions conviennent très bien.

Par contre, avec les conteneurs prenant un critère personnalisé, comme il faut préciser le type, ce n'est pas forcément plus simple d'utiliser une fonction libre (le type d'une fonction libre c'est plus technique à écrire).
Autant dans ce cas là utiliser un foncteur.

[stof]

EDIT : au fait, le const sert à indiquer au compilo que tu ne modifie pas la valeur. Quand ce n'est pas le cas, il ne faut pas en mettre...

Ben là je ne modifie rien pourtant (je compare); c'est le compilateur qui n'est pas content.

Parce que les algos générique de la STL font appel à l'opérateur ()...
(...)
Un foncteur est par définition une classe avec l'operator () défini!

Hum, faut que je vois ces histoires de foncteur (pour passer quelque part un argument qui identifie la classe)

[Florian Goo]

Hum, faut que je vois ces histoires de foncteur (pour passer quelque part un argument qui identifie la classe)

Le « quelque part » sera le constructeur de la classe test !
Enfin… si ça identifie la classe et pas l'objet, ce serait plutôt un paramètre template.

[stof]

OK (sauf que je connaissais les classes et constructeurs mais j'ai découvert cette façon d'utiliser une structure comme une classe).

Reste la raison pour laquelle les const ne sont pas passés à la compilation mais bon, peu importe puisque ça compile quand je les enlève.

[Florian Goo]

Ce serait tout de même intéressant que tu saches pourquoi !

À mon avis, ça vient du fait que tu accèdes directement au champ name de ta classe.
Il faudrait que tu écrives un accesseur (== getter) pour cette variable, et qui aurait cette tête là :

Code :

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

1
2
3
4
5
 
const char* const get_name() const
{
    return name;
}

Si tu ne comprends pas ce code, n'hésite pas à demander.

[stof]

En fait voilà en gros ce qui est fait :

Code :

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

1
2
3
4
5
6
7
struct test                                                                                     
{                                                                                                          
	bool operator()(/*const*/ Cmyclass& t1, /*const*/ Cmyclass& t2)   {                                         
 
	return strcmp(t1.getNom().getChaine(), t2.getNom().getChaine()) < 0;
}
}

où le type renvoyé par getNom() est du CMyChaine et la fonction getChaine() va renvoyer un type char* (j'avais éluder ça pour simplifier ma question)

Code :

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

1
2
3
4
char* CMyChaine ::getChaine(void)const
{
	return *_chaine;
}

Donc tout est bien fait via accesseurs; où est le problème?

[Florian Goo]

Le mieux serait que tu nous montres le message d'erreur.

Passer par des accesseurs ne suffit pas. Il faut aussi que ceux-ci soient const. Cmyclass::getNom() l'est-il ?

[stof]

Code :

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

CMyChaine getNom() {return _nom;}

Enfin c'était juste pour votre information; je crois que je comprend d'après ce que tu dis qu'il faudrait que toutes les sous-fonctions appelées à chaque fois soient en const.

Ce qui n'est pas le cas de getNom().

Merci.

[Médinoc]

Enfin, pour que du code soit correct et "safe", il ne suffit pas que les fonctions soient const, mais il faut aussi qu'elles soient const-correctes : Ta fonction getChaine doit renvoyer un const char *.