Discussion :

[manitor]

Bien, alors, j'aimerais bien trouver moi-même où est l'erreur, mais je n'y arrive pas... Et malgré les heures passées à écrire du code, j'ai toujours l'impression d'être au niveau débutant!

J'ai une classe Hexagon qui contient un pointeur vers une classe YPiece. Une YPiece contient deux Hexagon.

Voilà la déclaration de Hexagon:

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
#include <vector>
#include <boost/array.hpp>
#include "PointMat.h"
class YPiece;
 
typedef boost::array<double,6> DoubleArray6;
 
class Hexagon{
 
private:
	int m_Index;
	const YPiece*  m_YPce;
	DoubleArray6 m_Lengths;
	std::vector<PointMatH> m_Vertices;
 
public:
	inline Hexagon(const Hexagon& p_Hex);
	Hexagon(int, const YPiece*, const double, const double, const double);
};

le cpp:

Code :

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

1
2
3
4
5
6
7
#include "Hexagon.h"
#include "YPiece.h"
inline Hexagon::Hexagon(const Hexagon& p_Hex):
	m_Index(p_Hex.m_Index), m_YPce(p_Hex.m_YPce), m_Lengths(p_Hex.m_Lengths), m_Vertices(p_Hex.m_Vertices){};
Hexagon::Hexagon(int p_Index, const YPiece* p_YPce, const double p_L1, const double p_L3, const double p_L5):
	m_Index(p_Index),m_YPce(p_YPce){
...}

Voilà celle de YPiece:

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
#include <string>
#include <vector>
#include "Hexagon.h"
#include "Collar.h"
typedef std::vector<Collar*> CollarArray;
 
class YPiece{
private:
	std::string m_Name;
	Hexagon m_Hex1;
	Hexagon m_Hex2;
 
public:
	CollarArray m_Collars;
 
	YPiece(const std::string& p_Name):m_Name(p_Name){m_Collars.reserve(3);};
	YPiece(const YPiece& p_YPce): m_Name(p_YPce.m_Name),m_Hex1(p_YPce.m_Hex1),m_Hex2(p_YPce.m_Hex2),m_Collars(p_YPce.m_Collars){};
 
	void SetYPieceHexagons(){};

le cpp:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
#include "YPiece.h"
#include "Hexagon.h"
void YPiece::SetYPieceHexagons(){
	double l_Length1((m_Collars.at(0)->GetLength())/2);
	double l_Length3((m_Collars.at(1)->GetLength())/2);
	double l_Length5((m_Collars.at(2)->GetLength())/2);
	Hexagon H1(1, this, l_Length1, l_Length3, l_Length5);
	Hexagon H2(2, this, l_Length1, l_Length3, l_Length5);
}

C'est le "this" de SetYPieceHexagons() qui pose problème, je crois... Le but est d'en faire le pointeur m_YPce dont Hexagon a besoin.
Si quelqu'un a une idée...

[LittleWhite]

Bonjour,

Quel est le message d'erreur renvoyé par le compilateur ?

Avez vous bien mis les include nécessaire (notamment celui du Hexagon pour le fichier YPiece.hpp) ?

[manitor]

Bonjour, merci pour la réponse... Mon message était effectivement mal écrit, j'avais essayé de condenser en mettant directement dans la déclaration de la classe le constructeur de Hexagon et la fonction SetYPieceHexagons... J'ai modifié maintenant. Concernant les include, je crois que ça devrait marcher comme ça...

Le début du message d'erreur est celui-là:

Code :

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

1
2
3
4
5
 
Undefined symbols:
  "PointD::DistanceTo(PointD const&) const", referenced from:
      Hexagon::Hexagon(int, YPiece const*, double, double, double)in Hexagon.o
      Hexagon::Hexagon(int, YPiece const*, double, double, double)in Hexagon.o

C'est le genre de message que j'ai toujours du mal à comprendre parce que l'erreur n'est jamais indiquée à la ligne posant problème. Si ça se trouve, l'erreur n'est pas celle à laquelle je pense!

J'imagine les sourires se dessinant sur vos visages...

[LittleWhite]

Le compilateur dit qu'il ne trouve pas la fonction DistanceTo qui doit être dans la classe Point.
Moi, lorsque j'ai cette erreur, c'est que j'ai oublié de mettre le "Point::" lors de la définition de la méthode dans le .cpp de Point.
Genre, actuellement vous avez :

Code :

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

1
2
3
4
5
 
void DistanceTo(...)
{
...
}

Alors que cela devrait être :

Code :

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

1
2
3
4
5
 
void Point::DistanceTo(...)
{
...
}

[manitor]

En fait, si jamais, le "tu" ne me dérange pas bien au contraire!

La fonction DistanceTo en question, je l'ai déclarée dans le header PointD.h, par contre, je ne l'ai pas encore implémentée... Mais cela ne devrait pas poser de problème, non?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
#include <complex>
typedef std::complex<double> Complex;
class PointD{
private:
	Complex m_Z;
 
public:
	PointD(double p_x, double p_y):m_Z(p_x,p_y){};
 
	const Complex& GetZ() const {return m_Z;};
 
	double DistanceTo(const PointD&) const;
};

Je remets aussi le message d'erreur en entier, ce sera peut-être plus utile (je pensais que l'erreur n'était liée qu'à ce constructeur d'Hexagon qui prenait un this en argument):

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
 
Building target: HG_Triangulation2
Invoking: MacOS X C++ Linker
g++  -o "HG_Triangulation2"  ./Collar.o ./Hexagon.o ./PointD.o ./PolygonD.o ./Surface.o ./YPiece.o ./main.o   
Undefined symbols:
  "PointD::DistanceTo(PointD const&) const", referenced from:
      Hexagon::Hexagon(int, YPiece const*, double, double, double)in Hexagon.o
      Hexagon::Hexagon(int, YPiece const*, double, double, double)in Hexagon.o
  "YPiece::YPiece(YPiece const&)", referenced from:
      std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, YPiece>::pair(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, YPiece const&)in Surface.o
      std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, YPiece>::pair(std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, YPiece> const&)in Surface.o
  "YPiece::YPiece(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)", referenced from:
      Surface::Surface(__gnu_cxx::__normal_iterator<Collar*, std::vector<Collar, std::allocator<Collar> > >, __gnu_cxx::__normal_iterator<Collar*, std::vector<Collar, std::allocator<Collar> > >)in Surface.o
      Surface::Surface(__gnu_cxx::__normal_iterator<Collar*, std::vector<Collar, std::allocator<Collar> > >, __gnu_cxx::__normal_iterator<Collar*, std::vector<Collar, std::allocator<Collar> > >)in Surface.o
  "PointMatH::PointMatH(PointD const&)", referenced from:
      Hexagon::Hexagon(int, YPiece const*, double, double, double)in Hexagon.o
      Hexagon::Hexagon(int, YPiece const*, double, double, double)in Hexagon.o
ld: symbol(s) not found
collect2: ld returned 1 exit status
make: *** [HG_Triangulation2] Error 1

(la partie du milieu, je ne comprends pas du tout...)

[Bousk]

Et bien si, une fonction non implémentée qu'on essaye d'utiliser, le linker perd la boule.
Il t'indique justement qu'il la trouve pas, à juste titre.


Imagine-toi partir en vacances, ton pote te dit qu'il a la voiture; ça c'est le header, qui indique ce qui existe (en théorie - tout n'est pas forcément implémenté encore)
Venu le moment du départ (le linker), s'il n'a pas apporté la voiture, t'es dans la merde ; ce qui existe, si on souhaite l'utiliser, doit être défini