Méthode virtuelle et héritage

cyril_sy

25 août 2007 à 23:43:53

Bonjour à tous,
J'aimerais faire quelque chose dans ce genre:

class Node{
public:
int h,g,f;
};
class Graph{
public:
virtual vector<Node*> getNeighbors(Node* from) = 0;
virtual int getCost(Node* from, Node* to) = 0;
virtual int heuristic(Node* from, Node* to) = 0;
};
class myNode : public Node{
public:
int x, y, cost;
};
class myGraph : public Graph{
public:
vector<myNode*> getNeighbors(myNode* from);
int getCost(myNode* from, myNode* to);
int heuristic(Node* from, Node* to);
private:
vector<myNode*> map;
};

Le problème, c'est que

int getCost(myNode* from, myNode* to);

n'implémente pas

virtual int getCost(Node* from, Node* to) = 0;

donc j'ai cette erreur à la compilation quand j'instancie myGraph:

error: cannot declare variable 'graph' to be of type 'myGraph'
error: because the following virtual functions are abstract:
et il me sort les fonctions abstraites.

J'ai pensé aux templates, mais Graph ne doit renvoyer que des Node ou fils...

Est ce qu'il existe une solution à mon problème?

merci pour votre aide

minirop

25 août 2007 à 23:50:22

une classe pour être instanciable doit redéfinie obligatoirement toutes les méthodes virtuelles pures de ses classes mères.

cyril_sy

26 août 2007 à 0:06:01

Oui ça je le savais.

Ce que je veux faire dans l'idée:

template<typename T>
class Graph{
public:
virtual vector<T*> getNeighbors(T* from) = 0;
virtual int getCost(T* from, T* to) = 0;
virtual int heuristic(T* from, T* to) = 0;
};
class myGraph : public Graph<myNode>{
public:
vector<myNode*> getNeighbors(myNode* from);
...
}

où T serait obligatoirement Node ou fils de Node

Skypers

26 août 2007 à 0:07:22

Une classe "fille" doit pour être instanciable redéfinir obligatoirement toutes les méthodes virtuelles pures de ses classes mères ... Oui je sais je chippotte un peu ...

pamaury

26 août 2007 à 9:45:47

Si tu veux que çà compile, pzrtout où tu utilise myNode dans ta classe myGraph, tu remplace par Node.
De plus, je vois pas l'intérêt de définir Node puis de la dériver pour ensuite n'utiliser que sa classe dérivée...(et utiliser tous ces pointeurs).

cyril_sy

26 août 2007 à 12:05:21

En fait je suis en train de faire un pathfinder (il cherche un chemin à travers un Graph de Nodes).

Pour fonctionner il a besoin des parramètres de Node (par exemple, un bool pour savoir s'il l'a deja étudié).

Il a aussi besoin d'un graph qui lui donne des infos quand il le souhaite (par exemple, "donne moi les voisins de ce node").

Ensuite je donne à l'utilisateur (ou moi :-°

) la classe abstraite du Graph pour qu'il puisse le definir comme il veut. la seule contrainte c'est de permettre au pathfinder de dialoguer avec, il doit donc implémenter les fonctions virtuelles à sa sauce.

Pour l'instant c'est fait

.

Maintenant je veux qu'il puisse aussi dériver les Nodes:

Par exemple si le graphe est une carte 2D, pour implémenter la fonction "donne moi les voisins de ce node", ça serait beaucoup plus rapide, si "ce node" contenait des paramètres x,y;

Si par contre le graphe est un reseau, ça serait plus rapide si "ce node" contenait un tableau de pointeurs vers ses voisins.

Comme ça sa m'éviterais de devoir recoder le pathfinder à chaque fois que je change de graphe...

Biensur, ici j'ai donné un bout de code pour l'exemple, je ne vais pas vous donner mon vrai code, ça serait incompréhenssible sans le contexte

iNaKoll

26 août 2007 à 13:20:25

Bonjour !

Ne t'inquiètes pas pour nous et envoie nous ton code !

J'ai déjà essayé d'implémenter une classe de graphe et je suis curieux de voir comment tu t'en sors !

Edit :
Une petite question : l'heuristique que tu utilises, c'est une distance de manhattan ? ou une distance euclidienne ?

Inkamath on GitHub - Interpréteur d'expressions mathématiques. Reprise du développement en cours.

HanLee

26 août 2007 à 15:32:41

Citation : cyril_sy

En fait je suis en train de faire un pathfinder (il cherche un chemin à travers un Graph de Nodes).

Pour fonctionner il a besoin des parramètres de Node (par exemple, un bool pour savoir s'il l'a deja étudié).

Il a aussi besoin d'un graph qui lui donne des infos quand il le souhaite (par exemple, "donne moi les voisins de ce node").

Ensuite je donne à l'utilisateur (ou moi ) la classe abstraite du Graph pour qu'il puisse le definir comme il veut. la seule contrainte c'est de permettre au pathfinder de dialoguer avec, il doit donc implémenter les fonctions virtuelles à sa sauce.

Pour l'instant c'est fait .

Maintenant je veux qu'il puisse aussi dériver les Nodes:

Par exemple si le graphe est une carte 2D, pour implémenter la fonction "donne moi les voisins de ce node", ça serait beaucoup plus rapide, si "ce node" contenait des paramètres x,y;

Si par contre le graphe est un reseau, ça serait plus rapide si "ce node" contenait un tableau de pointeurs vers ses voisins.

Comme ça sa m'éviterais de devoir recoder le pathfinder à chaque fois que je change de graphe...

Biensur, ici j'ai donné un bout de code pour l'exemple, je ne vais pas vous donner mon vrai code, ça serait incompréhenssible sans le contexte .

Je t'ai répondu sur Developpez.net.

cyril_sy

26 août 2007 à 22:44:10

Citation : iNaKoll

Une petite question : l'heuristique que tu utilises, c'est une distance de manhattan ? ou une distance euclidienne ?

Tu sais, A-start ne sert pas qu'a trouver un chemin sur une map 2D. Dans mon cas c'est a travers une image, donc une map 2D. Mais je cherche à relier un pixel à une ligne de pixel, en utilisant le moins d'energie possible :-°

. Je n'utilise donc ni l'une, ni l'autre

.

C'est intrigant non? pour plus d'infos, regarde cette vidéo...

Pour ceux qui veulent mon code (la partie pathfinding), je l'ai mis sur developpez.net

Merci pour votre aide