Probleme de template dans un fichier .cpp

Version imprimable

Bonjour,

j'ai un problème avec ces deux morceaux de codes:
C'est à dire que quand je compile il me dit qu'il y'a une erreur
dans le .cpp, il ne connait pas le " T " et il y'a une utilisation invalide
du template.

Je vous remercie d'avance pour votre aide !

Rq: Forme.h est la classe mère de Cercle

Cercle.cpp
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 #include <iostream> #include <string> #include "Cercle.h" using namespace std; template<typename T> Cercle::Cercle(T p_rayon,string p_nom): rayon(p_rayon),Forme(p_nom) {} T Cercle:: getRayon(){ return rayon; }
Cercle.h
Code:

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 #ifndef DEF_CERCLE #define DEF_CERCLE #include<string> #include "Forme.h" using namespace std; template<typename T=int>//template par défaut = int class Cercle : public Forme { public: Cercle(T p_rayon,string p_nom); T getRayon(); private: T rayon; }; #endif

28/09/2014, 20h41
Bousk

Salut,

un template ça s'implémente dans un header.
http://cpp.developpez.com/faq/cpp/?p...tion-des-liens

Bonjour,

Le template, si il est utilisé dans un fichier cpp, doit être définit.

Deux options :

Tout définir dans le .h
.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#ifndef DEF_CERCLE
#define DEF_CERCLE
//==============================================================================
#include <string>
//------------------------------------------------------------------------------
#include "Forme.h"
//==============================================================================
template<typename T = int>//template par défaut = int
class Cercle : public Forme
{
//------------------------------------------------------------------------------
public:
    Cercle(const std::string& p_nom, const T p_rayon)
    : Forme(p_nom), m_rayon(p_rayon) {}
 
    T getRayon() const { return m_rayon; }
//------------------------------------------------------------------------------
private:
    T m_rayon;
};
//==============================================================================
#endif

Specialiser le template dans le .cpp
.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
#ifndef DEF_CERCLE
#define DEF_CERCLE
//==============================================================================
#include <string>
//------------------------------------------------------------------------------
#include "Forme.h"
//==============================================================================
template<typename T = int>//template par défaut = int
class Cercle : public Forme
{
//------------------------------------------------------------------------------
public:
    Cercle(const std::string& p_nom, const T p_rayon);
    T getRayon() const;
//------------------------------------------------------------------------------
private:
    T m_rayon;
};
//==============================================================================
#endif

.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <iostream>
#include <string>
//------------------------------------------------------------------------------
#include "Cercle.h"
//------------------------------------------------------------------------------
using namespace std;
//==============================================================================
template<>
Cercle<int>::Cercle(const std::string& p_nom, const int p_rayon)
: Forme(p_nom), m_rayon(p_rayon) {}
//------------------------------------------------------------------------------
template<>
int Cercle<int>::getRayon() const 
{
    return rayon;
}
//==============================================================================

Les fonctions de classes template définies dans le .cpp doivent toutes être prefixées de template<> et de plus elles devront connaitre le type.
(Pas forcement utile dans ce cas, cela obligerait à redefinir le constructeur et la fonction pour chaque type différents.)

PS penser à mettre les arguements qui ne sont pas modifible en const, et utiliser les références si ceux-ci sont ne sont pas de simple valeurs (int, char ...)
Les fonctions qui ne modifient rien seront constantes.
Ne jamais utiliser de "using namespace std;" dans un header (.h)

29/09/2014, 10h47
ternel
Par ailleurs, il y a une erreur sur qui est template.

la classe déclaration est:
Code:

1 2 3 4 template <typename T> class Cercle { public: Cercle(T p_rayon,string p_nom); };
Ta définition était celle de template <typename T> Cercle::Cercle(T p_rayon,string p_nom).
Ce n'est pas la même chose.
Cette définition s'occupe de la template pour tout type T de la fonction (en l'occurence un constructeur) Cercle(T, string) de la classe Cercle.
Sauf que tu veux la fonction Cercle(T, string) de la template pour tout type T de la classe Cercle.
C'est à dire template <typename T> Cercle<T>::Cercle(T p_rayon,string p_nom).

Ceci n'enlève rien aux explications précédentes :D

y'a une partie que je ne comprends pas, en mettant des <int> dans le .cpp (dans le code en bas)
on perd le template. C'est à dire que si je fais

Code:

1
2
 
    Cercle<int> monCercle("Mon 1er Cercle",14);

ça marche, mais si je fais

Code:

1
2
 
    Cercle<long> monCercle("Mon 1er Cercle",14);

ça ne marche plus

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
 
#include <iostream>
#include <string>
//------------------------------------------------------------------------------
#include "Cercle.h"
//------------------------------------------------------------------------------
using namespace std;
//==============================================================================
template<>
Cercle<int>::Cercle(const std::string& p_nom, const int p_rayon)
: Forme(p_nom), m_rayon(p_rayon) {}
//------------------------------------------------------------------------------
template<>
int Cercle<int>::getRayon() const
{
    return m_rayon;
}
//==============================================================================

Citation:

Les fonctions de classes template définies dans le .cpp doivent toutes être prefixées de template<> et de plus elles devront connaitre le type.
(Pas forcement utile dans ce cas, cela obligerait à redefinir le constructeur et la fonction pour chaque type différents.)

Bon, je suis pas des gars les plus clair 8-)

Les templates définies dans le fichier source devront être spécialisées, c'est à dire qu'elle devront explicitement definir le type.(cette spécialisation peut aussi être faite dans le header).

C'est pour cela que dans de cas précis, il n'y a pas (a priori) d'interêt à utiliser de fichier source (.cpp), le seul header (.h) suffira à déclarer cette classe, pour garder en généricité.

Un petit exemple pour mieux comprendre l'interêt de la spécialisation : (pas vraiment d'intérêt mais c'est pour donner une idée)
Code:

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 //============================================================================== #include <iostream> //------------------------------------------------------------------------------ struct CircleTag {}; struct SquareTag {}; //------------------------------------------------------------------------------ template<typename FormTag> struct Form { void print() const; }; //------------------------------------------------------------------------------ template<>//Ainsi spécialisé, peut être mis dans un .cpp void Form<CircleTag>::print() const { std::cout << "Cercle" << std::endl; } //------------------------------------------------------------------------------ template<> void Form<SquareTag>::print() const { std::cout << "Carre" << std::endl; } //============================================================================== int main() { Form<CircleTag> cercle; Form<SquareTag> carre; cercle.print();//Affiche Cercle carre.print();//Affiche Carre return 0; } //==============================================================================

01/10/2014, 14h44
bouritosse

ok merci, j'ai compris