Discussion :

[Nekkro]

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]

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]

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]

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)

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

avec la balise CODEINLINE

[Nekkro]

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

[koala01]

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]

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]

Bonjour koala,

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?