Spécialisation de template et g++

**Nekkro** · 21/10/2011, 18h22

Bonjour,

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

Code :

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

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 :

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 ?

**gbdivers** · 21/10/2011, 18h57

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 :

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
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 :

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
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

**Nekkro** · 21/10/2011, 21h05

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 ?

**gbdivers** · 21/10/2011, 23h04

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)

Envoyé par Nekkro

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

avec la balise CODEINLINE

**Nekkro** · 22/10/2011, 11h17

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

**koala01** · 22/10/2011, 11h17

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 :

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

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 :

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

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

)

**Nekkro** · 22/10/2011, 11h53

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

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
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 :

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

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 ...

**Aleph69** · 22/10/2011, 15h21

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

**koala01** · 22/10/2011, 15h59

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

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

**koala01** · 22/10/2011, 16h06

Envoyé par Nekkro

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

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
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 :

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

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

**Steph_ng8** · 22/10/2011, 18h47

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 ?

Envoyé par koala01

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

Erreur de ta part.

Code La preuve par le (contre-)exemple :

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
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;
}

**Nekkro** · 22/10/2011, 22h19

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 ?

**Flob90** · 23/10/2011, 00h59

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 :

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
 
#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); }

**3DArchi** · 23/10/2011, 10h20

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 :

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
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)
{
}

**Aleph69** · 24/10/2011, 10h43

Bonjour koala,

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?

**gbdivers** · 24/10/2011, 13h55

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 :

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

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 :

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

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 :

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

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

En corrigeant, cela fonctionne :

Code :

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

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)

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

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 :

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

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).

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

**Nekkro** · 24/10/2011, 17h27

@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 :

**gbdivers** · 24/10/2011, 17h56

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 :

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

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.

**Nekkro** · 24/10/2011, 18h02

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 :

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 ^^