Discussion :

[yves.dessertine]

Bonjour à tous,

je ne sais plus quoi chercher pour utiliser une fonction membre d'une classe template sans que le linker ne râle. Je n'arrive pas à linker (mais bien à compiler) le code suivant :

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
#ifndef MAILLON_HPP
#define MAILLON_HPP
 
template <class T>
class Maillon {
 
private:
  T data;
  Maillon<T> *suivant;
 
 
public:
  Maillon();
  ~Maillon();
};
 
 
#endif //MAILLON_HPP

(maillon.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
#include <iostream>
using namespace std;
 
#include "maillon.hpp"
 
 
template <class T> Maillon<T>::Maillon()
{
  cout << "constructeur de maillon" << endl;
  suivant = NULL;
}
 
template <class T> Maillon<T>::~Maillon()
{
  delete suivant;
  suivant = NULL;
}

(maillon.cpp)

Code :

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

1
2
3
4
5
6
7
8
 
#include "maillon.hpp"
 
int main()
{
  Maillon<int> m;
  return 0;
}

(client.cpp)

g++ -c maillon.cpp ==> OK
g++ -c client.cpp ==> OK
g++ client.o maillon.o ==> compile mais ne linke pas :

Code :

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

1
2
3
4
5
client.o(.text+0x17): In function `main':
: undefined reference to `Maillon<int>::Maillon[in-charge]()'
client.o(.text+0x22): In function `main':
: undefined reference to `Maillon<int>::~Maillon [in-charge]()'
collect2: ld returned 1 exit status

Par contre, lorsque je remplace maillon.cpp par :

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
#include <iostream>
using namespace std;
 
#include "maillon.hpp"
 
 
Maillon<int>::Maillon()
{
  cout << "constructeur de maillon" << endl;
  suivant = NULL;
}
 
Maillon<int>::~Maillon()
{
  delete suivant;
  suivant = NULL;
}

Eh bien là, ô miracle, ça linke (mais ça n'est plus un vrai beau template)......

je suis preneur si vous avez une idée, merci à vous !

P.S. : que veut dire "in-charge" ?

[sas]

il ne faut pas séparer la déclaration et la définition d'un template de la même manière qu'une classe ordinaire, regroupe-les et ton code compilera.

par exemple :

maillon.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
24
25
26
27
28
29
30
31
32
33
 
#ifndef MAILLON_HPP
#define MAILLON_HPP
 
#include <iostream>
 
template <class T>
class Maillon {
 
private:
  T data;
  Maillon<T> *suivant;
 
 
public:
  Maillon();
  ~Maillon();
};
 
 
template <class T> Maillon<T>::Maillon()
{
  std::cout << "constructeur de maillon" << std::endl;
  suivant = NULL;
}
 
template <class T> Maillon<T>::~Maillon()
{
  delete suivant;
  suivant = NULL;
}
 
#endif //MAILLON_HPP

main.cpp

Code :

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

1
2
3
4
5
6
7
8
9
 
#include "maillon.hpp"
 
int main()
{
  Maillon<int> m;
 
  return 0;
}

plus d'info dans la faq.

[mathieu_t]

Si tu veux garder ta configuration bien pratique de séparer les .h et les .cpp, tu peux faire un

Code :

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

#include "MonFichier.cpp"

dans le .hpp....

A+

[Jan Rendek]

C'est bien de séparer déclaration et implémentation, mais utiliser la même
extension pour du code source et pour la définition de template c'est dangereux.
Souvent l'extension '.tcc' est utilisée pour cela.

[Laurent Gomila]

N'oubliez pas la

http://c.developpez.com/faq/cpp/?pag...VERS_templates

[yves.dessertine]

Tout d'abord, merci infiniment à tous ceux qui ont répondu, vos réponses sont très pertinentes ! Merci également pour le coup de la faq (je n'avais pas trouvé avant avec google, bien que j'aie cherché longtemps !). On ne m'y reprendra plus

Mais la solution de tout mettre dans le .h ne me satisfait pas complètement, parce que contraire aux principes de la compilation séparée.

Donc, j'aimerai laisser les implémentations de fonctions membres dans un fichier à part. Vous m'avez parlé de .tcc, mais j'ai aussi trouvé .tpp ailleurs. Je crois que j'envisage de garder .hpp, .cpp et .tpp pour des questions d'homogénéité. C'est pas contraire à quelque chose j'espère ?

Maintenant, la question de la façon de faire :

• - tout mettre dans le .hpp => pas terrible à mon avis (on pourrait corriger la FAQ ?)
  - inclure le .tpp dans le .hpp et vice versa => bof, qu'en pensez-vous ? On croise un peu les include là...
  - inclure le .hpp dans le .tpp, puis inclure le .tpp dans le main => ???
  - include le .tpp ET le .hpp dans le main => ???

Quelle est la meilleure façon de faire à votre avis ? Je tiens à prendre de bonnes habitudes tant que je n'y connais rien

Merci d'avance !

[yves.dessertine]

Ou bien tout mettre dans le .tpp ? (comme expliqué ici : http://www.cplusplus.com/doc/tutorial/tut5-1.html à la fin de la page ?)

Help

[mathieu_t]

inclure le .tpp dans le .hpp et vice versa => bof, qu'en pensez-vous ? On croise un peu les include là...

Tu peux le faire tant que tu gères bien les #ifndef / #define / #endif dans chaque fichier.

Le plus simple et le plus homogène au reste est d'inclure le .cpp (ou .tpp pour les puristes) dans le .hpp !

Quant à donner une extension en tpp au lieu de cpp, moi je trouve ça bien inutile, puisque d'un point de vue extérieur ça revient à la même chose (même si les fonctionnements internes ne sont pas les mêmes) et que justement le but d'une programmation haut niveau est de s'éloigner au max des contraintes de plus bas niveau...

A+

[Jan Rendek]

Mais la solution de tout mettre dans le .h ne me satisfait pas complètement, parce que contraire aux principes de la compilation séparée.

Les instances dérivées des templates sont compilées dans chaques unité de compilation
qui les utilises. A ma connaissance, aucun compilateur ne permet à ce jour l'export
d'instance de template, bien que cela fasse un bail qu'on en parle.

En d'autres termes, tu ne peux pas compiler séparément une classe template.

Quand à inclure le fichier de définition (tcc ou autre) dans le fichier d'entête, bof.
S'il n'y a aucun besoin de séparer l'entête de la définition, je ne vois pas pourquoi le faire.
Cette séparation n'est dûe qu'au mécanisme de compilation séparée pour ce qui est des
fichiers classique. Je ne vois pas pourquoi s'encombrer d'un tel mécanisme.

Pour moi, il y a un seul cas ou pour un template il faille séparer déclaration et définition. C'est quand deux classes templates sont clientes l'une de l'autre.
Dans ce cas, effectivement, le compilateur doit pouvoir disposer des déclaration des deux, avant de parcourir leur définitions.
Pour le reste, c'est s'encombrer de fichiers supplémentaires, qui impliquent un surcout
de maintenance inutile.

[Aurelien.Regat-Barrel]

Mais la solution de tout mettre dans le .h ne me satisfait pas complètement, parce que contraire aux principes de la compilation séparée.

sauf que tu n'as pas vraiment le choix, car un template ça se compile pas tel quel, il faut d'abord l'instancier. C'est du méta code, qui sert à la génération de code qui lui est compilé... c'est pour ça qu'on a besoin de tout son contenu, car tel quel y'a rien de compilable. C'est comme vouloir compiler une macro.
Y'a le mot clé export que le compilo Comeau supporte, mais à part celui là...

[Jan Rendek]

Il en fait quelque chose du 'export' Comeau ?
Parce que beaucoup de compilo l'acceptent ce mot clef, il me semble même qu'il fait
partie du standard. Mais, la plupart l'ignore.

[Luc Hermitte]

Dans le désordre.

- Avec les templates, il est courant et attendu de faire en sorte que l'inclusion des déclarations (typiquement .h, .hpp, .hxx, ...) charge aussi les définitions. Tu peux tout mélanger à la Java (avec un bon éditeur de texte capable de replier (-> to fold), cela passe tout seul), tu peux avoir ton .h qui inclue les définitions inlinées, ...

- Avoir des définitions de templates déplacées dans un .cpp n'est pas un problème de puritanisme, c'est un problème pratique. Il existe diverses chaines de compilations qui traiteront automatiquement le .cpp comme un fichier à compiler (VC, gmake, ...). Or, c'est justement ce qu'il ne faut surtout pas faire.

- Export est supporté par les compilos reposant sur le produit d'EDG -> comeau, intel, et un autre je crois. Ceci dit, je ne sais plus si il n'y avait pas eu des variations dans le support du bestio.

[yves.dessertine]

Merci à vous tous !!

Si nos profs nous expliquaient les choses aussi bien, ça serait vraiment le bonheur !

Je comprends tous vos points de vue. Finalement c'est vrai que séparer déclaration et implémentation n'a pas d'intérêt dans le cas des templates (je n'ai que GCC/G++, donc voilà). À part celui d'éditer des fichiers séparés...

J'ai opté pour des fichier .tpp mélant déclatations (prototypes) de classes et impémentations, à inclure (comme ça ils ne risquent pas d'être traités comme des modules par les règles génériques de make). D'ailleurs, même Emacs ne les reconnait pas par défaut comme du C++

--
Yves, nouveau fan qui va essayer d'aider les autres dans la limite de ses connaissances.