Probleme appel des gestions de classes / appelles de methodes
Bonjours tout le monde,
Je débute en C++ et j'apprend un peu "sur le tas",e t la je suis face à un probleme qui commence a me titiller severement...
Il est fort possble que ce probleme découle d'une mauvaise comprehension de l'OO, mais je débute et j'apprend "sur le tas"...
En Gros mon probleme.
jai une class A(IProblem) dont je veux me servir comme "interface" (enfaite jai repris du code Java que j'ai tanter de traduire en C++... en sachant que je ne metrise ni l'un..ni l'autre...)
Une classe B(CaM) qui implemente ces methodes
et pour terminer une class C(ISolver) qui va faire des actions sur des objet A mais je veux que ce soit "traiter" par ma class B ... Enfin c'est compliquer, et je suis un peu dans le flou au niveau des concept et de la terminologie OO.. Voila mon code (c'est un peu brut, mais j'ai essayer de supprimer des choses inutiles).
Il y'a des choses qui vont vous apraitre abherrante (genre des attribut public ...) mais je tatonne, j'avance bout par bout.... Et j'aimerais bien avoir un resultat avant de me lancer dans le relifting "propre" de mon code...
Si quelqu'un m'a suivit jusque là et ce sent le courage de jetter un oeil...
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
| #ifndef _GENERIC
#define _GENERIC
#include <string>
#include <list>
#include <iostream>
using namespace std;
class IState{
public:
virtual void printState() =0;
};
class aCaMState : public IState{
public:
int nbMr_, nbCr_, nbMl_, nbCl_;
string pos_;
public:
aCaMState(int nbMl, int nbCl,int nbMr, int nbCr,string pos){
//.....
}
}; |
La classe IState est une "interface" au sens java de la classe aCamState. L'idée c'est de pouvoir travailler avec des "interfaces" peut importe leur implementation..
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
class IProblem{
public :
//----- methods -----
virtual IState * INIT()=0;
virtual bool GOAL( IState * state_ ){};
virtual list<Triplet *> SUCCESSOR_FN( IState * state_ ){};
};
class CaM : public IProblem{
public:
aCaMState * INIT(){return new aCaMState(0,0,3,3,"D");}
bool GOAL(aCaMState * state_ ){//implementation... }
virtual list<Triplet *> SUCCESSOR_FN( aCaMState * state_ ){//implementation... };
}; |
La classe don CaM, qui est une implémentation de la classe IProblem. C'est là que les choses commencent à être délicates...
J'essaye d'expliquer clairement :
les ISlover (dont ci-dessous on a une implémentation sous la forme d'un treeSearch) doivent pouvoir manipuler des IProblem sans avoir à ce soucier de leur "type" exact (ici CaM), et le but est justement de pouvoir jouer avec différentes "implémentations" des interfaces "abstraites" sans avoir à modifier celles-ci.
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
43
44
45
46
47
48
49
50
|
class ISolver{
//----- methods -----
public:
virtual void SOLUTION( Node * node_ ) {};
list <Node *> EXPAND( IProblem * problem_, Node * node_ ){
//...implementaiton de la fonction
}
};
class treeSearch : public ISolver{
public :
void SOLUTION(Node * node_){
//....
};
treeSearch( IProblem * problem_, list<Node *> fringe_ )
{
fringe_.push_back( new Node( problem_->INIT() ) );
do
{
Node * node = * fringe_.begin();
fringe_.pop_front();
cout<<node->ACTION()<<endl;
(node->STATE())->printState();
cout<<node->DEPTH()<<endl;
if( problem_->GOAL( node->STATE() ) ) //la fonction GOAL utilisée est celle déclarée dans IProblem
{
SOLUTION( node );
break;
}
fringe_.insert(fringe_.end(), EXPAND( problem_, node ).begin(),EXPAND( problem_, node ).end() );
}
while( !fringe_.empty () );
}
};
#endif |
Le problème ce situe donc ici :
Code:
1
2
3
4
5
| if( problem_->GOAL( node->STATE() ) ) //la fonction GOAL utiliser est celle déclarer dans IProblem
{
SOLUTION( node );
break;
} |
node->STATE renvoie effectivement un ISTate, et la fonction appeler est donc GOAL() déclarer dans IProblem, hors j'aimerais que ce soit celle de CaM (enfaite en general de la classe fille de IProblem).
Voici aussi la classe Node que j'aurais peut-Être du mettre dès le départ...:
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| class Node{
private:
int depth;
int path_cost;
Node * parent;
IState * state;
string action;
public: //----- accessors -----
//.....
//----- constructors -----
Node ( IState * state_, Node * parent_, string action_,
int path_cost_, int depth_ ){}
Node ( IState * state_ ){}
}; |
Je me demande si des templates, en lieu et place de mes bancales "virtual pures" fonctions, ne resoudrait pas mon problème... Enfin je suis toujours preneur des idées de personnes plus rigoureuses et renseignée que moi....
