Discussion :

[Neckara]

Bonjour,

Étant un peu en avance à un TP, mon prof de C++ m'a demandé de faire en sorte de redéfinir bool operator<(Creature *, Creature *).

Il pensait que ce serait possible en utilisant des templates mais après essais et renseignement, ce n'est pas possible de cette manière.

J'ai tenté de créer une classe dont le constructeur prend en paramètre un Creature * en espérant avoir une conversion implicite mais cela ne marche pas non plus.

Mon professeur pense que l'opérateur< a été défini de manière générique et qu'il se peut qu'il cast les pointeurs vers des pointeurs void *.
Le but serait alors de définir quelque chose de plus spécifique pour créer notre propre operateur(Creature *, Creature *).

Auriez-vous des pistes ou des idées ?

[Trademark]

Salut,

Vu qu'un pointeur c'est un long (généralement) ton opérateur < va comparer des long. Normal non ?

Je pense que ça marcherait si tu passais par des références (constantes).

Ou si tu ne peux pas, il faudrait que tu crées un foncteur/fonction de comparaison que tu passerais là où tu en as besoin.

[jabbounet]

peut que jeter un oeil ici t'aidera:

http://cpp.developpez.com/faq/cpp/?p...ator_inferieur

http://stackoverflow.com/questions/4...or-overloading

http://www.cplusplus.com/reference/std/functional/less/


Cordialement.
Frédéric

[Neckara]

Vu qu'un pointeur c'est un long (généralement) ton opérateur < va comparer des long. Normal non ?

Un pointeur n'est pas un long, c'est un type à part entière :
-int * ptr; long test = ptr; refusera de compiler.
L'opérateur < va comparer la valeur des pointeurs.

Je pense que ça marcherait si tu passais par des références (constantes).

Malheureusement, le compilateur n'accepte pas aussi les référence sur des pointeurs constants.

Ou si tu ne peux pas, il faudrait que tu crées un foncteur/fonction de comparaison que tu passerais là où tu en as besoin.

peut que jeter un oeil ici t'aidera:

http://cpp.developpez.com/faq/cpp/?p...ator_inferieur

http://stackoverflow.com/questions/4...or-overloading

http://www.cplusplus.com/reference/std/functional/less/

Oui je sais mais ce n'est pas le but^^
La meilleur solution étant d'utiliser des shared_ptr au lieu d'utiliser de simples pointeurs.

Mais les Creature * ne sont pas des built-in type, ce sont des user-defined type donc en théorie il devrait être possible de surcharger un opérateur avec des pointeurs sur Creatures.

Il doit aussi y avoir quelque chose de générique pour la comparaison de pointeurs et donc on doit pouvoir apporter une définition plus spécialisée qui nous permettrait de redéfinir l'opérateur à moins qu'il y ai dans la définition des pointeurs quelque chose de spécial qui nous échappe ?

[JolyLoic]

On ne peut pas :

An operator function shall either be a non-static member function or be a non-member function and have at least one parameter whose type is a class, a reference to a class, an enumeration, or a reference to an enumeration.

L’opérateur < est défini sur les pointeurs, quel que soit leur type, et on n'en peut mais...

[Neckara]

L’opérateur < est défini sur les pointeurs, quel que soit leur type, et on n'en peut mais...

Je dois avouer que je suis un petit peu perplexe.

Est-ce que cette interdiction est dû à la norme ou à une réelle contrainte technique ?
Un compilateur est pourtant capable de surcharger des opérateurs et de différencier des pointeurs pointant sur des objets de différents types.

Serait-ce dû au fait que certaines bibliothèques standard ont besoins de ces opérateurs pour n'importe quel pointeurs et que si on laissait à l'utilisateur la possibilité de changer le comportement de l'opérateur on ferait tout planter ?

[Jean-Marc.Bourguet]

Nulle part dans le langage on permet de remplacer une opération définie par le langage. Le plus proche est le remplacement des opérateurs new et delete globaux, qui relève de la bibliothèque.

[Neckara]

Nulle part dans le langage on permet de remplacer une opération définie par le langage. Le plus proche est le remplacement des opérateurs new et delete globaux, qui relève de la bibliothèque.

Je pense que j'ai compris, par exemple, pour calculer le nombre d'éléments d'un vecteur, le vecteur utilise l'opérateur - sur deux pointeurs.
Or si on redéfini cet opérateur, on aura des résultats erronés.

On est donc obligé d'interdire la surcharge des opérateurs pour les pointeurs sinon on risque de se retrouver avec des comportements indéterminés et on ne peut plus utiliser l'arithmétique des pointeurs.

Merci pour vos réponses.

[jouana]

Bonjour,

J'ai regardé les 2 posts.
Si j'ai bien compris en gros tu as une comparaison a faire entre deux créatures et voir si les pv de l'un sont inférieur à l'autre.

Donc c'est possible par la surcharge d'opérateur (je ne rentrerais pas dans les débat vu sur les posts vu que c'est purement pédagogique dans ton cas).

Alors la solution n'est pas très compliqué enfaîte tu as juste a faire comme ceci

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
 
class creature
{
     int pv;
 
    public:
    int getPv()...
 
    friend bool operator<(creature&, creature&);
}
 
bool operator<(creature* a, creature* b)
{
   if (a.getPv() < b.getPv())
      return true;
   return false;
}

Normalement de mémoire ça marche.
(petite correction ajoutée).

Bonne journée.

[Bousk]

Non c'est strictement impossible de redéfinir un opérateur sur des pointeurs.
La syntaxe serait

Code :

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

bool operator<(const Creature&, const Creature&);

[jouana]

Effectivement au temps pour moi.
Désolé pour mon erreur.

Bonne journée

[ternel]

Et il n'est pas utile de rendre l'operateur friend s'il n'utilise que l'accesseur public.