Discussion :

[gb_68]

Bonjour,

j'ai de petits soucis avec la spécialisation d'une fonction membre ; la seule solution que j'ai trouvée étant pour l'instant de la déclarer toujours en inline (VC++ 2005).

Exemple:

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
26
27
28
29
30
31
32
33
34
35
#pragma once
#ifndef __TTESTTEMPLATE__ 
#define __TTESTTEMPLATE__ 
 
class TTestTemplate
{
public:
    template<typename T>
    int FnctMembre(T t)
    {
        return 1;
    }  
 
    // Passe en VC++, mais pas vraiment légal en C++ il me semble
    template<>
    int FnctMembre<int>(int t)
    {
        return 2;
    }
};
 
/* Problème à l'édition des liens (la fonction se trouve déclaré dans plusieurs modules) 
template<>
int TTestTemplate::FnctMembre<char>(char t)
{
    return 3;
}
*/
 
template<>
inline int TTestTemplate::FnctMembre<double>(double t)
{
    return 4;
}
#endif //__TTESTTEMPLATE__

Cette spécialisation doit-elle alors toujours être inline ?
Remarque : il m'est déjà arrivé de placer des spécialisations dans un cpp, en ne donnant pas l'implémentation par défaut.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
// .h
class TTestTemplate
{
public:
    template<typename T>
    int FnctMembre(T t); // échoue si il n'existe pas une spécialisation adéquate
};
// .cpp
template<>
int TTestTemplate::FnctMembre<char>(char t)
{
   return 1;
}

Mais cela force à ne pas donner l'implémentation par défaut, sinon elle sera utilisée pour générer une spécialisation et entrera en conflit l'autre (de plus je ne suis pas très sur de la légalité d'un tel code ).

[Florian Goo]

Bonjour,

Ça s'écrit comme ça :

Code :

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

1
2
3
4
5
6
 
    template<>
    int FnctMembre<>(int t)
    {
        return 2;
    }

[3DArchi]

Salut
Tu peux déclarer tes spécialisations dans le .h et les définir dans le .cpp :
// .h :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
class TTestTemplate
{
public:
    template<typename T>
    int FnctMembre(T t){//version par defaut}
};
template<> int TTestTemplate::FnctMembre<char>(char t);
template<> int TTestTemplate::FnctMembre<std::string>(std::string t);
template<> int TTestTemplate::FnctMembre<CMaClasse>(CMaClasse t);

//.cpp

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
template<> int TTestTemplate::FnctMembre<char>(char t)
{
...
}
template<> int TTestTemplate::FnctMembre<std::string>(std::string t)
{
...
}
template<> int TTestTemplate::FnctMembre<CMaClasse>(CMaClasse t)
{
...
}

Bien sûr la version général doit rester dans le .h

[gb_68]

Merci pour vos réponses.

Ça s'écrit comme ça :

Code :

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

1
2
3
4
5
6
 
    template<>
    int FnctMembre<>(int t)
    {
        return 2;
    }

Je n'étais pas sûr si c'était légal (VC++ l'accepte, mais entre VC++ accepte et être autorisé en C++, comment dire ... ).

Salut
Tu peux déclarer tes spécialisations dans le .h et les définir dans le .cpp :
// .h :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
class TTestTemplate
{
public:
    template<typename T>
    int FnctMembre(T t){//version par defaut}
};
template<> int TTestTemplate::FnctMembre<char>(char t);
template<> int TTestTemplate::FnctMembre<std::string>(std::string t);
template<> int TTestTemplate::FnctMembre<CMaClasse>(CMaClasse t);

//.cpp

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
template<> int TTestTemplate::FnctMembre<char>(char t)
{
...
}
template<> int TTestTemplate::FnctMembre<std::string>(std::string t)
{
...
}
template<> int TTestTemplate::FnctMembre<CMaClasse>(CMaClasse t)
{
...
}

Excellent .
Cella permet aussi d'exclure la version générale par un static assert (Boost, fait maison ou C++0x), plus propre que de laisser l'édition des liens échouer.
Merci encore