Discussion :

[Chido42]

Bonjour à tous, alors voila pour mon problème il s'agit d'un problème que je rencontre régulierement lorsque je code en C++ aussi je vous demande votre aide pour qu'enfin je sache le résoudre ^^.

Voici mon code :

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
/*
 * EtatRobot.cpp
 *
 *  Created on: 12 déc. 2009
 *      Author: blanc
 */
 
#include "EtatRobot.h"
#include "Position.h"
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
 
EtatRobot::EtatRobot() {
	direction = "Nord";
	position = new Position(0,0);
	obstacle = NULL;
	objet = NULL;
	robot = new Robot();
}
 
EtatRobot::~EtatRobot() {
	// TODO Auto-generated destructor stub
}

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
/*
 * EtatRobot.h
 *
 *  Created on: 12 déc. 2009
 *      Author: blanc
 */
 
#ifndef ETATROBOT_H_
#define ETATROBOT_H_
 
#include "Robot.h"
#include "Position.h"
#include "Obstacle.h"
#include "Objet.h"
#include <string>
 
using namespace std;
class Robot;
 
class EtatRobot {
private:
	Robot* robot;
	string nomEtat;
	string direction;
	Position* position;
	Obstacle* obstacle;
	Objet* objet;
public:
	EtatRobot();
	virtual ~EtatRobot();
};
 
#endif /* ETATROBOT_H_ */

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
#include "Robot.h"
#include "Position.h"
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
 
using namespace std;
 
//class EtatRobot;
 
Robot::Robot()
{
	direction = "Nord";
	position = new Position(0,0);
	obstacle = NULL;
	objet = NULL;
	etat = new EtatRobot();
}
 
Robot::~Robot() {
	// TODO Auto-generated destructor stub
}
 
void Robot::avancer(int distance)
{
	cout << "Le robot avance de " << distance << " cm.\n";
}
void Robot::tourner(string direction)
{
	cout << "Le robot tourne vers la direction " << direction << ".\n";
}
void Robot::saisir(Objet* o)
{
	objet = o;
	cout << "Le robot saisi l'objet.\n";
}
void Robot::poser()
{
	objet = NULL;
	cout << "Le robot pose l'objet;\n";
}
void Robot::peser()
{
	cout << "Le robot pèse l'objet... L'objet pèse : " << objet->getPoids() << " grammes.\n";
}
void Robot::rencontrerObstacle(Obstacle* o)
{
	obstacle = o;
	cout << "Le robot rencontre un obstacle\n";
}
void Robot::evaluerObstacle()
{
	cout << "Le robot evalue l'obstacle... Il a pour hauteur " << obstacle->getHauteur() << "cm.\n";
}
void Robot::arreter()
{
	cout << "Le robot s'arrete";
}
void Robot::repartir()
{
	cout << "Le robot redémarre";
}
 
void Robot::afficher() {
	cout << "Affiche le chemin parcouru par le robot";
}
 
Position* Robot::getPosition() {
	return position;
}
 
Obstacle* Robot::getObstacle() {
	return obstacle;
}
 
Objet* Robot::getObjet() {
	return objet;
}
 
string Robot::getDirection() {
	return direction;
}

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
43
44
45
46
47
/*
 * Robot.h
 *
 *  Created on: 27 nov. 2009
 *      Author: Chido
 */
 
#ifndef ROBOT_H_
#define ROBOT_H_
 
#include "EtatRobot.h"
#include "Position.h"
#include "Obstacle.h"
#include "Objet.h"
#include <string>
 
using namespace std;
 
 
 
class Robot {
private:
	string direction;
	Position* position;
	Obstacle* obstacle;
	Objet* objet;
	EtatRobot* etat;
public:
	Robot();
	virtual ~Robot();
	void avancer(int distance);
	void tourner(string direction);
	void saisir(Objet* o);
	void poser();
	void peser();
	void rencontrerObstacle(Obstacle* o);
	void evaluerObstacle();
	void arreter();
	void repartir();
	void afficher();
	Position* getPosition();
	Obstacle* getObstacle();
	Objet* getObjet();
	string getDirection();
};
 
#endif /* ROBOT_H_ */

Mon problème est donc dans le Robot.cpp qui me met une erreur à la ligne 17 : etat = new EtatRobot();

L'erreur étant undefined reference to EtatRobot::EtatRobot()

Je n'ai pas inclu le code des autres classes dites moi si cela est necessaire.
Je code sous ubuntu 9.10 avec eclipse.

Voila merci d'avance en esperant que cette question n'ai pas été déjà trop poser j'ai chercher rapidement mais je suis dans le train donc ma connection n'est pas idéale.

Edit : J'ai essayer avec class EtatRobot; et sans même résultat... J'ai essayer d'inclure le .h directement dans le CPP pas de différence. La seule maniere que j'ai trouver est de ne pas initialiser mon instance etat mais bon j'en ai besoin :s

[AndreiS]

Essaye de déplacer la ligne '#include "Robot.h"' du fichier EtatRobot.h à EtatRobot.cpp . Ce n'est pas nécessaire dans le h parce que tu peut utiliser la 'forward declaration' 'class Robot' sans inclure le header.

[Chido42]

Merci pour ta réponse.
Cela fonctionne aussi, malheureusement ne résout pas mon problème :/. mon etat = new EtatRobot(); a toujours le même problème.

D'autre suggestion ?

[JolyLoic]

Je ne connais pas eclipse et peu gcc, donc je n'ai pas forcément l'habitude des messages d'erreurs, mais ce message ressemble plus à un problème au link qu'à un problème de compilation. Ce qui signifie probablement qu'il y a un problème dans ton makefile/projet qui fait que les deux fichiers .o/.obj/.??? qui sont générés par la compilation de tes cpp ne se voient pas l'un l'autre.


A part ça, dans le constructeur de Robot, tu fait new EtatRobot, et dans celui d'EtatRobot, tu fais new Robot... Ne penses-tu pas que tu vas avoir des soucis ?

[Chido42]

En effet il risque d'y avoir un probleme :s. La solution serait de initialiser mon robot dans une autre méthode que mon constructeur alors ? Sinon pour le makefile en effet j'avais oublier de créer les nouvelles dépendances
Même si mon problème n'est pas résolu (je pense en effet que le fait de faire appel l'une a l'autre dans les constructeurs doit poser problème. Donc je vais chercher un peu merci en tout cas pour le coup de main. Je vous tiens informer de l'avancement ^^

[Chido42]

Bon bah je confirme probleme resolu j'initialise ma variable etat dans une autre méthode et sa fonctionne . Merci pour le coup de main

[koala01]

Salut,

Bon bah je confirme probleme resolu j'initialise ma variable etat dans une autre méthode et sa fonctionne . Merci pour le coup de main

Je ne suis vraiment pas sur que ce soit la bonne façon de faire...

Typiquement, lorsque tu crée un robot, il devrait être dans un état connu...

L'état n'ayant connaissance du robot auquel il fait allusion que... pour te permettre de retrouver le robot en question

D'un autre coté, il est peu vraisemblable que l'état ne soit pas relié à un robot particulier lorsqu'il (je parle de l'état ici) est créé, et encore moins que l'état d'un robot soit "transféré" à un autre robot .

Dés lors, pourquoi ne pas:

• fournir le pointeur vers le robot (existant) concerné au constructeur de l'état
• appeler directement new EtatRobot(this) dans le constructeur de Robot

Cela aurait en outre l'avantage de briser les dépendances circulaires
Au final, cela donnerait un code proche de
etatrobot.h
class Robot;

Code :

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

1
2
3
4
5
6
7
8
9
10
class EtatRobot
{
    public:
        EtatRobot(Robot* r):m_robot(r)
        {
            /*...*/
        }
    private:
        Robot m_robot;
};

robot.h

Code :

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

1
2
3
4
5
6
7
8
9
#include "EtatRobot.h"
class Robot
{
    public:
        Robot(/*...*/):m_etat(new EtatRobot(this) ){}
        /*...*/
    private:
        EtatRobot m_etat;
};

PS: il ne faut jamais mettre une directive using namespace libre dans un fichier d'en-tête, car elle a la sale manie de se répercuter sur l'ensemble des fichier qui incluent le fichier d'en-tête de manière directe ou indirecte

[Chido42]

Merci pour ta réponse. En effet je pense que le fait de passer en argument un pointeur vers le robot pour EtatRobot est une bonne solution. Après il faut que je demande a mon enseignant si cela suit tout de même les consignes (nous avons déjà crée le diagramme de classe du projet qui a été validé par le professeur). Sinon concernant le using namespace dans ce cas il faut que je le place ou ? dans les .cpp ??

Merci encore pour vos réponses

[koala01]

Merci pour ta réponse. En effet je pense que le fait de passer en argument un pointeur vers le robot pour EtatRobot est une bonne solution. Après il faut que je demande a mon enseignant si cela suit tout de même les consignes (nous avons déjà crée le diagramme de classe du projet qui a été validé par le professeur).

Normalement, cela apparait plutôt dans un diagramme de séquence, et non dans un diagramme de classe

Sinon concernant le using namespace dans ce cas il faut que je le place ou ? dans les .cpp ??

Oui, dans le .cpp, voire, carrément, nulle part

Il faut cependant faire attention au fait que, tant que la directive using namespace n'est pas apparue dans le code, il faudra utiliser les nom pleinement qualifié de tes différentes classes/fonctions issues de l'espace de noms std...

C'est à dire que, dans le fichier d'en-tête, il faudra écrire std::vector, std::string, std::istream,...

Et c'est la raison pour laquelle je dis que la directive using namespace peut même ne pas apparaitre du tout: rien ne t'empêche, une fois que tu as pris l'habitude d'écrire les noms pleinement qualifiés, de le faire de manière systématique partout

[Chido42]

Oui sans doute une bonne habitude a prendre vu les problèmes que sa cause... Sinon c'est bon projet validé et rendu (en effet le diagramme de séquence c'est mieux mais encore faut il l'avoir déjà fait :p )

Merci en tout cas

[koala01]

Oui sans doute une bonne habitude a prendre vu les problèmes que sa cause...

Je présumes que tu parles de la directive using namespace...

Disons que, parfois, cela peut engendrer certains conflits, si, pour une raison ou une autre, tu te retrouve avec plusieurs classes portant le même nom dans des espaces de noms différents

Sinon c'est bon projet validé et rendu

c'est déjà une bonne chose

(en effet le diagramme de séquence c'est mieux mais encore faut il l'avoir déjà fait :p )

A vrai dire, la mise au point des diagrammes d'états et de séquence devrait être entreprise en parallèle avec celle du diagramme de classes.

En effet, ce sont ces deux diagrammes qui te permettent de visualiser les services que ta classe est susceptible de rendre, les messages qu'elle est susceptible d'émettre ou de recevoir, et donc de prévoir l'interface publique que tu devra mettre au point, ce qui permettra, en définitive de déterminer les relations (autres que l'héritage publique) existant entre les différentes classes de ton projet...

Tout cela pour dire que, normalement, lorsque tu commence à coder, ce sont des diagrammes qui devraient exister

Merci en tout cas

Mais, de rien