Discussion :

[younes008]

Bonjour,

Un bout de code très simple et que je n'arrive pas à compiler sous visual C++ Express.
Pourriez vous m'éclairer?
en vous remerciant d'avance.

Voici l'erreur que le compilateur me renvoie.

Code :

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

1
2
3
1>main.obj : error LNK2019: symbole externe non résolu "public: virtual __thiscall SimplePropertySet<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,double>::~SimplePropertySet<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,double>(void)" (??1?$SimplePropertySet@V?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@N@@UAE@XZ) référencé dans la fonction _main
1>main.obj : error LNK2019: symbole externe non résolu "public: __thiscall SimplePropertySet<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,double>::SimplePropertySet<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,double>(class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > const &)" (??0?$SimplePropertySet@V?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@N@@QAE@ABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@Z) référencé dans la fonction _main
1>C:\Users\younes\Documents\Visual Studio 2008\Projects\testProperty\Debug\testProperty.exe : fatal error LNK1120: 2 externes non résolus

SimplePropertySet.hpp

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
 
#include <list>
#include <string>
#include <set>
 
using namespace std;
 
 
template <class N, class V> class SimplePropertySet
{
private:
 
	N nam;		// The name of the set
 
 
public:
	// Constructors and destructor
	SimplePropertySet();		// Default constructor
	SimplePropertySet(const N& name);		// Named property set
	SimplePropertySet(const SimplePropertySet<N,V>& source);	// Copy constructor
 
	virtual ~SimplePropertySet();	// Destructor
};

SimplePropertySet.cpp

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
 
#include "SimplePropertySet.hpp"
template <class N, class V>
SimplePropertySet<N,V>::SimplePropertySet()
{ // Default constructor
 
	nam = N();
}
 
template <class N, class V>
SimplePropertySet<N,V>::SimplePropertySet(const N& name)
{ // Named property set
 
	nam = name;
}
 
template <class N, class V>
SimplePropertySet<N,V>::SimplePropertySet(const SimplePropertySet<N,V>& source)
{ // Copy constructor
 
	nam = source.nam;
}
 
 
template <class N, class V>
SimplePropertySet<N,V>::~SimplePropertySet()
{ // Destructor
 
 
}

Main.cpp

Code :

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

1
2
3
4
5
6
7
8
 
#include "SimplePropertySet.hpp"
#include <iostream>
using namespace std;
int main()
{
	SimplePropertySet<string, double> input("Strike");
}

[koala01]

Salut, et bienvenue sur le forum.

Typiquement, l'erreur d'édition de liens survient, sur les classes templates, lorsque l'on a eu la mauvaise idée de séparer la déclaration des fonctions de leur implémentation.

En effet, le propre d'une classe template est de baser son comportement sur "je ne sais pas quel type de donnée je vais utiliser, mais je sais comment je vais l'utiliser", et de laisser le compilateur générer le code machine pour... chaque type de données manipulé...

Pour cela, il faut, lorsqu'il se rend compte que l'on utilise une classe template avec un type particulier, qu'il puisse disposer du code source des différentes fonctions.

Or, la directive préprocesseur #include ne fait qu'une chose : copier, à l'endroit où elle se trouve, le contenu du fichier dont le nom lui est passé.

De ce fait, lorsque tu écris

Code :

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

#include "SimplePropertySet.hpp"

dans main.cpp, tout ce que tu copie dans ce fichier, c'est... la définition de ta classe...

Et tu ne fournis pas au compilateur le code source (qui se trouve dans SimplePropertySet.cpp) qu'il devrait adapter pour... manipuler des std::string comme premier type et des double comme second.

Il est donc totalement incapable... de fournir le code binaire exécutable correspondant

Si tu veux, réelleemnt, séparer la définition de ta classe de l'implémentation de ses fonctions membres, il faudra t'assurer que le fichier contenant l'implémentation des fonctions soit lui aussi inclus lorsque tu as besoin de la classe.

Comme il se peut que le fait de voir l'inclusion d'un *.cpp soit de nature à en perturber plus d'un (normalement, un fichier portant cette extension n'est jamais inclus dans un autre), l'idéal sera de choisir une autre extension comme, par exemple, tpp ou tcc ou impl ou ...

Au fait, les fonctions virtuelles et les classes template font rarement bon ménage, à moins de savoir exactement ce que l'on fait:

Du fait que le compilateur a besoin de connaitre en permanence le code source des fonctions membres d'une classe template, nous sommes régulièrement confrontés au fait que ces fonctions seront... inline...

A contrario, une fonction virtuelle ayant d'office besoin d'un vtbl et étant susceptibles d'accorder leur comportement en fonction du type réellement manipulé, elles ne seront jamais inlinées...

L'idée de vouloir combiner les template et les fonctions virtuelles revient donc, le plus souvent, à vouloir combiner l'huile et l'eau : on a beau mélanger le tout, elles se séparent toujours

[younes008]

Merci pour ta réponse rapide, claire, et précise. Mon exemple marche à présent.

[Lavock]

Du fait que le compilateur a besoin de connaitre en permanence le code source des fonctions membres d'une classe template, nous sommes régulièrement confrontés au fait que ces fonctions seront... inline...

Hum, je dirai plus qu'elles sont statique dans le sens C du terme, à savoir que leur définition de dépasse pas la visibilité (au niveau des fichiers) de l'endroit où elles sont défini.

Inline en c++ rend les fonction "statiques" c-ment parlant, lorsque celle-ci ne sont pas, par choix d compilateur, inliné. La définition même d'un inline, c'est quand même de se passer du couple call/return.

Me suis-je fourvoyé ?