Discussion :

[Kaluza]

Bonjour à tous.

Petite question de débutant concernant les templates.
J'ai cru comprendre en effet qu'il ne fallait pas déclarer une fonction template dans un .cpp pour éviter de s'exposer à des risques inutiles.
Cependant, peut-on séparer le prototype de la déclaration d'une fonction template dans un .h ou c'est également dangereux ? (je précise que c'est uniquement par souci de lisibilité quand j'ai un grand nombre de fonctions)

Genre :

Code :

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

1
2
3
4
5
6
7
8
namespace mon_espace{
template<typename T> T ma_fonction(T ma_variable);
}
 
template<typename T> T mon_espace::ma_fonction(T ma_variable)
{
(blablabla...)
}

[3DArchi]

Salut,
Tu es tout à fait libre de séparer la déclaration de la définition d'une classe ou d'une fonction générique à l'instar d'une classe ou d'une fonction non générique. Cf ici par exemple.

La problématique exposée par exemple dans l'entrée de la F.A.Q. Pourquoi mes templates ne sont-ils pas reconnus à l'édition des liens ? est lié à la compilation séparée et au fait qu'un générique n'est réellement défini qu'au moment de son utilisation.

[Kaluza]

J'avais bien lu la FAQ, mais j'avais zappé le :

#include "exemple.tpp" // <-- astuce ici !!!

Merci 3DArchi

[koala01]

Salut,

Tu peux, cependant, trouver un "work arround" au problème, si tu connais par avance les types qui seront réellement utilisés par tes classes et fonctions templates, dans ce que l'on appelle l'instanciation explicite.

Tu peux, en effet, envisager de travailler avec trois (voir quatre) fichiers séparés sous une forme proche de
MyClass_def.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
/** Ce fichier ne contient que la déclaration de la classe et de ses fonctions 
  * membres, c'est à dire, tout ce que le compilateur doit connaitre au
  * moment où il rencontre une déclaration de variable
  */
#ifndef MYCLASS_DEF_HPP
#define MYCLASS_DEF_HPP
template <typename T/*, ...*/>
class MyClass
{
    public:
        MyClass(T t);
        T foo();
        /* tout ce dont tu as besoin */
    private:
       T t_;
};
#endif // MYCLASS_DEF_HPP

MyClass.impl

Code :

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

1
2
3
4
5
6
7
8
9
10
11
/* ce fichier contient l'implémentation des différentes fonctions de la classe
 *
 * il correspondrait au fichier .tpp de l'exemple
 */
template <typename T>
MyClass<T>::MyClass<T const & t):t_(t){}
template <typename T>
inline void MyClass<T>::foo()
{
    /* ce qui doit être fait */
}

MyClass_inst.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
#include "MyClass_def.hpp"
#include "MyClass.impl"
/* Dans ce fichier, nous forçons à la génération du code binaire pour
 * différents types dont nous savons que la classe sera utilisée avec
 */
/* nous savons que la classe sera utilisée avec des (signed) int */
template class MyClass<int>;
/* ainsi qu'avec de unsigned long long */
template class MyClass<unsigned long long> ;
/* des types personnalisés peuvent parfaitement être introduits 
 * penser à inclure les en-têtes correspondantes
 */
template class MyClass<UnTypePersonnalise>;
/* voire même des types template personnalisés */
template class MyClass< MonTypeTemplate<int> >;
/* en version C++1x : */
template class MyClass< MonTypeTemplate<int>>;

Enfin, il peut être utile de prévoir, malgré tout, un dernier fichier pour tous les types auxquels nous n'aurions pas pensés (et qui ne seront donc pas instanciés explicitement)
MyClass.hpp

Code :

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

1
2
3
4
5
6
 
#ifndef MYCLASS_HPP
#define MYCLASS_HPP
#include "MyClass_def.hpp"
#include "MyClass.impl"
#endif // MYCLASS_HPP

Pour tous les types instanciés implicitement (donc, a priori, tous ceux de ton projet, vu que tu saura que tu peux instancier explicitement ta classe pour des types donnés), tels que, selon mon exemple, int, unsigned long long, UnTypePersonnalise et MonTypeTemplate<int>, tu pourras inclure sans risque le seul fichier MyClass_def.hpp.

Si ta classe est réutilisée par quelqu'un d'autre, ou, du moins, avec un type qui n'a pas encore été instancié de manière explicite, il s'agira d'inclure MyClass.hpp

NOTA: j'ai choisi la facilité en instanciant de manière explicite l'ensemble de la classe, mais il est possible (sous condition toutefois) de n'instancier que certaines fonctions particulières de celle-ci