Spécialisation de template et g++

Bonjour,

Voici un code tout simple que je veux faire compiler avec g++ sous C::B :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

class X { public:   template <class T> T get_property () { }   template <> string get_property () { } };

---

J'ai malheureusement l'erreur suivante :

Citation:

---

error: explicit specialization in non-namespace scope 'class config'

---

Je veux pouvoir faire x->get_property () mais apparemment je n'ai pas le droit de spécialiser hors d'un namespace, ce qui ne me convient pas puisque je veux que la spécialisation soit une fonction membre de ma classe ... Que faire ?

Bonjour

La FAQ correspondante : Qu'est-ce que la spécialisation de template ?

La spécialisation d'une fonction template d'une classe est identique à la spécialisation d'une fonction :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

class X { public:   template <class T> T get_property() { return T(); } };   template<> std::string X::get_property<std::string>() { return std::string(); }   X x; x.get_property<int>(); x.get_property<std::string>();

---

PS : en fait, il est même préférable de bien séparé déclaration et définition donc sort de la classe la définition de ta fonction template :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

class X { public: template<typename T> T get_property(); };   template<typename T> T X::get_property() { return T(); }   template<> std::string X::get_property<std::string>() { return std::string(); }

---

PS2 : utilise typename au lieu de class dans les paramètres template
PS3 : je sais pas si c'est le cas mais ne fait pas de using namespace std; dans un fichier d'en-tête

Merci, j'avais beau avoir jeté un oeil à la FAQ, j'ai dû avoir zappé ce passage ...

J'ai néanmoins une question : si je sépare l'implémentation de la fonction de sa définition, je dois bien le faire dans le fichier .hpp pour les templates, et pas dans le .cpp ? (juste pour la confirmation).

Et non, je n'ai aucun #include ni aucun using namespace dans mes fichiers de header.

PS : Comment écrire un bout de ligne de code en ligne comme tu l'as fait ?

Citation:

---

Envoyé par Nekkro

J'ai néanmoins une question : si je sépare l'implémentation de la fonction de sa définition, je dois bien le faire dans le fichier .hpp pour les templates, et pas dans le .cpp ? (juste pour la confirmation).

---

Oui. Par contre, il arrive parfois que l'on déplace l'implémentation dans un autre fichier header pour des raisons de lisibilité (par exemple, dans un fichier xxx_impl.hpp)

Citation:

---

Envoyé par Nekkro

PS : Comment écrire un bout de ligne de code en ligne comme tu l'as fait ?

---

avec la balise CODEINLINE

Je te remercie, mon problème est résolu.

Salut,

Il y a cependant un dernier point sur lequel il faut attirer l'attention, c'est le fait que toutes les définitions de fonctions template (ou de fonction membres de classes template) doivent être déclarées inline, soit de manière implicite, parce que définies à l'intérieur de la définition de la classe

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

template <typename T> class MyClass { public: /* cette fonction sera automatiquement et implicitement considérée   * inline   */ void foo(T const & truc) { /* fais quelque chose */ } };

---

soit de manière explicite, lors de la définition

Code:

---

1 2 3 4 5 6 7 8 9 10 11

template <> class MyClass<std::string> { public: void foo(std::string const & truc); }; template <> inline MyClass<std::string>::foo(std::string const & truc) { /* spécialisation pour l'utilisation de std::string */ }

---

Autrement, comme le compilateur va créer le code binaire correspondant dans tous les fichiers d'implémentation dans lequel le fichier d'en-tête sera inclus (de manière directe ou indirecte), l'éditeur de lien ralera de trouver plusieurs fois le même symbole pour cette fonction et ne saura pas vers quelle adresse mémoire faire pointer l'appel de la fonction.

Le fait d'avoir indiqué (de manière implicite ou explicite) que la fonction est inline permet à l'éditeur de liens de savoir comment réagir face à cette présence mutliple du même symbole ;) (sans doute en ne gardant qu'une implémentation, si la fonction n'est pas effectivement inlinée ;))

J'ai modifié et voilà ce que ça donne :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

class Config { public: template <typename T> T get_property (const string & name, const T & default_value); /* ... */ };   template <typename T> inline T Config::get_property (const string & name, const T & default_value) { }   template <> inline const string & Config::get_property<string> (const string & name, const string & default_value) { }   template <> inline bool Config::get_property<bool> (const string & name, bool default_value) { }

---

Et j'ai les erreurs suivantes :

Code:

---

1 2

error: template-id 'get_property<std::string>' for 'const std::string& Config::get_property(const std::string&, const std::string&)' does not match any template declaration error: template-id 'get_property<bool>' for 'bool Config::get_property(const std::string&, bool)' does not match any template declaration

---

Je vous avoue ne pas bien comprendre l'erreur ...

Bonjour koala,

je n'ai jamais eu besoin de faire de l'expansion de code pour spécialiser mes classes génériques. Peux-tu fournir un code qui ne compile pas chez toi pour que je regarde?

Merci

Citation:

---

Envoyé par Aleph69

Bonjour koala,

je n'ai jamais eu besoin de faire de l'expansion de code pour spécialiser mes classes génériques. Peux-tu fournir un code qui ne compile pas chez toi pour que je regarde?

Merci

---

Merci, mais je n'ai pas de classe template spécialisée qui ne compile pas :D

Par contre, si tu veux des cas (qui compilent) dans lesquels l'implémentation des fonctions se fait en dehors de la définition de la classe, je crois que tu peux regarder tout simplement les fichiers d'en-tête de la bibliothèque standard :D

Citation:

---

Envoyé par Nekkro

J'ai modifié et voilà ce que ça donne :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

class Config { public: template <typename T> T get_property (const string & name, const T & default_value); /* ... */ };   template <typename T> inline T Config::get_property (const string & name, const T & default_value) { }   template <> inline const string & Config::get_property<string> (const string & name, const string & default_value) { }   template <> inline bool Config::get_property<bool> (const string & name, bool default_value) { }

---

Et j'ai les erreurs suivantes :

Code:

---

1 2

error: template-id 'get_property<std::string>' for 'const std::string& Config::get_property(const std::string&, const std::string&)' does not match any template declaration error: template-id 'get_property<bool>' for 'bool Config::get_property(const std::string&, bool)' does not match any template declaration

---

Je vous avoue ne pas bien comprendre l'erreur ...

---

Sauf erreur de ma part, tu ne peux pas spécialiser une fonction template d'une classe non template :P

Bonjour.

Il me semblait que l'utilisation du mot-clé template pour une fonction (membre ou non) impliquait qu'elle était inline.
Je me souviens d'ailleurs avoir compilé avec succès des fichiers avec des fonctions template non déclarées explicitement comme inline.
Coup de bol ou compilateur arrangeant/prévoyant ?

Citation:

---

Envoyé par koala01

Sauf erreur de ma part, tu ne peux pas spécialiser une fonction template d'une classe non template :P

---

Erreur de ta part. :D

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 35 36 37 38 39 40 41 42 43 44 45 46

#include <iostream> #include <string>   using namespace std;     class A {   public: template <typename T> void f();   };     #define AFF cout << this << "->A::" << __func__ << "()" << endl;     template <typename T> void A::f() { cout << this << "->A::" << __func__ << "<T>()" << endl; }     template <> void A::f<int>() { AFF; }   template <> void A::f<string>() { AFF; }     int main() { A o; o.f<int>(); o.f<bool>(); return 0; }

---

Juste par curiosité, j'ai tenté la compilation du code de Steph, et ça marche.

Après un rapide test, il semblerait que mon problème vienne du fait que je modifie le type de retour et qu'il ne correspond pas à la fonction template de base ...

Mais dans mon cas, ma valeur de retour est templatée donc comment je dois faire si je veux spécialiser avec une valeur de retour différente ?

Edit: Je me suis compliqué la vie pour pas grand chose, la solution de 3DArchi est bien mieux, cf message suivant.

Tu peux spécialiser même si tu as un type de retour template dans ton modèle. La seul condition c'est que le compilateur puisse matcher ta spécialisation avec le modèle, dit autrement : qu'il puisse trouver un T qui fasse correspondre totalement ta spécialisation à la déclaration template avec ce T spécifique.

Si c'est sur la valeur retour tu peux utiliser une classe de trait : ca te permet d'avoir un type de retour différent de T sans perdre la déduction des arguments templates.

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

#include<iostream>   class A { template<class T> struct ReturnTrait { typedef T Type; };   public: template<class T> typename ReturnTrait<T>::Type foo(T&) { return ReturnTrait<T>::Type(); } };   template<> struct A::ReturnTrait<int> { typedef int& Type; };   template<> inline int& /*ou A::ReturnTrait<int>::Type*/ A::foo(int& i) { return i; }   int main() { A a; int i(1); double j(1); std::cout << a.foo(i) << ' ' << a.foo(j); }

---

Salut,

Sinon, il y a la surcharge qui donne moins mal aux cheveux et fonctionne parfaitement (plutôt qu'une discutable spécialisation d'une fonction) :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

class Config { public: template <typename T> T get_property (const string & name, const T & default_value); const string & get_property(const string & name, const string & default_value); bool get_property (const string & name, bool default_value); };   template <typename T> inline T Config::get_property (const string & name, const T & default_value) { }   inline const string & Config::get_property(const string & name, const string & default_value) { }   inline bool Config::get_property(const string & name, bool default_value) { }

---

Bonjour koala,

Citation:

---

Envoyé par koala01

Autrement, comme le compilateur va créer le code binaire correspondant dans tous les fichiers d'implémentation dans lequel le fichier d'en-tête sera inclus (de manière directe ou indirecte), l'éditeur de lien ralera de trouver plusieurs fois le même symbole pour cette fonction et ne saura pas vers quelle adresse mémoire faire pointer l'appel de la fonction.

---

tu ne peux pas provoquer le problème de définition multiple que tu mentionnes?

Citation:

---

Envoyé par Nekkro

J'ai modifié et voilà ce que ça donne :
(...)
Je vous avoue ne pas bien comprendre l'erreur ...

---

Le problème vient du fait que tu donnes une nouvelle "signature" à tes fonctions spécialisées qui ne correspondent pas à la "signature" de ta fonction template. D'où le message du compilateur does not match any template declaration qui signifie que tes spécialisations ne correspondent pas un template.

Ta fonction template :

Code:

---

1 2 3

template <typename T> inline T Config::get_property (const string & name, const T & default_value) { }

---

Pour ta spécialisation avec bool, tu supprimes le const& de default_value :

Code:

---

1 2 3

template <> inline bool Config::get_property<bool> (const string & name, bool default_value) { }

---

Pour la spécialisation avec std::string, tu ajoutes un const& dans le paramètre de retour

Code:

---

1 2 3

template <> inline const string & Config::get_property<string> (const string & name, const string & default_value) { }

---

En corrigeant, cela fonctionne :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

template <typename T> inline T Config::get_property (const string & name, const T & default_value) { }   template <> inline std::string Config::get_property<std::string> (const string & name, const std::string & default_value) { }   template <> inline bool Config::get_property<bool> (const string & name, const bool & default_value) { }

---

Hors sujet (mais cette discussion en contient déjà plein :) ) :

J'ai mis le mot "signature" entre guillemets parce que normalement, le paramètre de retour n'entre pas en ligne de compte. Or ici, le fait d'ajouter const& dans le paramètre de retour empêche le compilateur de trouver la fonction template. Il faudra que je regarde ça à l'occasion (sauf si quelqu'un à une source expliquant ce point)

Citation:

---

Envoyé par koala01

Sauf erreur de ma part, tu ne peux pas spécialiser une fonction template d'une classe non template

---

Quand on donne du code compilable (ce qui est la cas ici), je teste systématiquement ma réponse pour éviter une faute de frappe ou d'inattention. Donc pas d'inquiétude, ça fonctionne :)

Citation:

---

Envoyé par 3DArchi

plutôt qu'une discutable spécialisation d'une fonction

---

Je me suis posé la question aussi de l'utilité de spécialisée uniquement une fonction. Le seul exemple concret que j'ai trouvé est de créer une fonction de conversion permettant d'avoir des types templates compatible :

Code:

---

1 2 3 4

class A { template<typename T> A operator= (T const& a) { return a; } };

---

Et je ne vois pas de raison de spécialiser une telle fonction. Donc effectivement, peut être qu'il n'y a pas de raison de spécialiser ces fonctions get_property (il faudrait voir le code interne des fonctions).

Citation:

---

Envoyé par 3DArchi

Sinon, il y a la surcharge qui donne moins mal aux cheveux et fonctionne parfaitement

---

C'est effectivement plus simple. Par contre, la spécialisation permet d'éviter de modifier l'interface de la classe, ce qui est mieux à mon avis d'un point de vue respect de l'OCP.

@Nekkro
Quel genre de spécialisation souhaites tu faire dans tes fonctions ?
Pour info, j'ai l'impression que tu souhaites faire une "property map". Dans ce cas, je te conseille un coup d'oeil à boost::property_map

@gbdivers : Je souhaite faire une simple classe pour charger mes fichiers de configurations pour mon projet.

En passant, ton code de correction marche effectivement mais tu te contredis : tu me dis d'abord de retirer le const & de ma version avec bool (ce qui ne marche pas d’ailleurs) puis dans le code final il y est toujours (code final qui marche).

Si je veux spécialiser mes fonctions, c'est pour accélérer le fonctionnement dans le cas de string et dans le cas de bool :

http://img685.imageshack.us/img685/729/configspe.png

Tu m'as mal lu (ou je n'ai pas été claire) : c'est dans ton code qu'il manque un const& (pour bool) et qu'il y a un const& de trop (pour string). Le code que j'indiquais (avec la mise en gras) est le tiens. Mon code est celui qui est corrigé et qui fonctionne :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

template <typename T> inline T Config::get_property (const string & name, const T & default_value) { }   template <> inline std::string Config::get_property<std::string> (const string & name, const std::string & default_value) { }   template <> inline bool Config::get_property<bool> (const string & name, const bool & default_value) { }

---

Donc c'est bon, ça fonctionne ?

Par contre, je ne comprends pas (et ne vois pas dans le code que tu as donné) l’optimisation que tu souhaites faire. Et j'espère que tu es sur de la nécessité de faire une optimisation.

Pour la version string, j'empêche simplement de passer par une conversion inutile (from_string<string>()) et pour bool pareil, en faisant un simple test. Ça va juste plus être plus rapide.

Par contre si je te cite dans ton précédent message :

Citation:

---

Pour ta spécialisation avec bool, tu supprimes le const & de default_value

---

Alors qu'au contraire je devais l'ajouter. Si j'ai faux bah on s'est simplement mal compris ^^

Bonjour.

Citation:

---

Envoyé par Nekkro

Par contre si je te cite dans ton précédent message :

Citation:

---

Pour ta spécialisation avec bool, tu supprimes le const & de default_value

---

Alors qu'au contraire je devais l'ajouter. Si j'ai faux bah on s'est simplement mal compris ^^

---

Si je puis me permettre, je pense que la phrase de gbdivers est moins sujette à une mauvaise interprétation si on la tourne de cette manière :

Citation:

---

Pour ta spécialisation avec bool, tu as supprimé le const & de default_value

---

Oui, on s'est mal compris

Citation:

---

Envoyé par Nekkro

Citation:

---

Envoyé par gbdivers

Pour ta spécialisation avec bool, tu supprimes le const & de default_value

---

Alors qu'au contraire je devais l'ajouter.

---

Je voulais dire que tu as supprimé le const& entre la version template et ta spécialisation (et donc oui, il fallait ajouter le const& dans la spécialisation pour avoir du code correcte)

Ma tournure de phrase était malheureuse :) par contre, il suffisant de relire le code d'origine pour voir que je parlais bien de ton code.

Quoiqu'il en soit, ça tourne alors je résous la chose. Au passage si quelqu'un peut m'aider pour mes problèmes de boost, ce serait bienvenue, apparemment personne ne veut me répondre malgré les nombreuses lectures ... :/