modèle de spécialisation pour les fonctions membres statiques; howto?

Je suis en train de mettre en œuvre une fonction de modèle avec poignées vide différemment selon le modèle de la spécialisation.

Le code suivant me donne une "Explicite spécialisation dans le non-espace de noms de champ" dans gcc:

template <typename T>
static T safeGuiCall(boost::function<T ()> _f)
{
    if (_f.empty())
        throw GuiException("Function pointer empty");
    {
        ThreadGuard g;
        T ret = _f();
        return ret;
    }
}

//template specialization for functions wit no return value
template <>
static void safeGuiCall<void>(boost::function<void ()> _f)
{
    if (_f.empty())
        throw GuiException("Function pointer empty");
    {
        ThreadGuard g;
        _f();
    }
}

J'ai essayé de sortir de la classe (la classe n'est pas basé sur un modèle) et dans l'espace de noms mais puis-je obtenir le message d'erreur "Explicite la spécialisation ne peut pas avoir une classe de stockage". J'ai lu beaucoup de discussions à ce sujet, mais les gens ne semblent pas s'entendre sur la façon de se spécialiser fonction des modèles. Des idées?

OriginalL'auteur Rolle | 2009-04-20

boost c++templates

15

Lorsque vous spécialiser basé sur un modèle de méthode, vous devez le faire à l'extérieur de la classe des crochets:
```
template <typename X> struct Test {}; //to simulate type dependency

struct X //class declaration: only generic
{
   template <typename T>
   static void f( Test<T> );
};

//template definition:
template <typename T>
void X::f( Test<T> ) {
   std::cout << "generic" << std::endl;
}
template <>
inline void X::f<void>( Test<void> ) {
   std::cout << "specific" << std::endl;
}

int main()
{
   Test<int> ti;
   Test<void> tv;
   X::f( ti ); //prints 'generic'
   X::f( tv ); //prints 'specific'
}
```
Lorsque vous le prenez à l'extérieur de la classe, vous devez supprimer le "statique" mot-clé. Mot-clé Static à l'extérieur de la classe a un sens différent de ce que vous voulez probablement.
```
template <typename X> struct Test {}; //to simulate type dependency

template <typename T>
void f( Test<T> ) {
   std::cout << "generic" << std::endl;
}
template <>
void f<void>( Test<void> ) {
   std::cout << "specific" << std::endl;
}

int main()
{
   Test<int> ti;
   Test<void> tv;
   f( ti ); //prints 'generic'
   f( tv ); //prints 'specific'
}
```
hm, j'ai essayé la même chose, mais dans une .php fichier et essayé y compris... alors je reçois le message d'erreur "définition de plusieurs de vodu X:ff<void> (Test<void>). Je ne vois pas quelle serait la différence?
Était-il un compilateur ou l'éditeur de liens d'erreur? Si c'était une erreur de compilation, cela signifie que vous êtes probablement, y compris le modèle d'en-tête plus d'une fois et l'en-tête des gardes sont manquantes, et ainsi la double définition: le compilateur est de voir deux (hélas exactement exact) définitions pour la mise en œuvre.
Pourquoi ai-je l'ajouter en ligne pour le premier cas? Si pas, j'obtiens une erreur de compilation.
Je ne suis pas sûr de ce que le premier cas se réfère à... modèle de fonctions n'ont pas besoin de inline, modèle de spécialisations en avoir besoin si vous mettez la définition de l'en-tête (pour éviter de RLL violations)
C'est sur les spécialisations; si je le déplacer à partir de l'en-tête .rpc (et encore le modèle en tête), j'ai toujours l'erreur de définition de plusieurs ou de << a pas défini de chaîne (alias char*).

OriginalL'auteur David Rodríguez - dribeas
4

Ce n'est pas directement une réponse à votre question, mais vous pouvez écrire ce
```
template <typename T>
static T safeGuiCall(boost::function<T ()> _f)
{
        if (_f.empty())
                throw GuiException("Function pointer empty");
        {
                ThreadGuard g;
                return _f();
        }
}
```
Il doit fonctionner même si _f() return 'void'

Edit : Dans un cas plus général, je pense que nous devrions préférer les surcharges de fonctions au lieu de la spécialisation. Voici une bonne explication à cela : http://www.gotw.ca/publications/mill17.htm

oui très bon point

OriginalL'auteur Rexxar
3

Vous pouvez déclarer de manière explicite de la spécialisation de la même manière que vous le feriez définir une fonction membre en dehors de sa classe:
```
class A
{
public:
  template <typename T>
  static void foo () {}
};

template <>
void A::foo<void> ()
{
}
```
Merci pour la réponse. Pour moi, il n'importe pas s'ils sont à l'intérieur d'une classe ou pas; mais je ne peux pas le faire fonctionner dans les deux sens. Est ma syntaxe mauvais ou quelque chose dans le code que j'ai fourni?
Le point est que vous avez explicitement spécialiser la fonction dans l'espace de noms compétents de la fonction de demande de déclaration. C++ ne permet pas de rajouter la "statique" mot clé de sorte que vous suffit de le retirer. Mon exemple ci-dessus vous montre comment explicitement spécialiser un membre statique.

OriginalL'auteur Richard Corden
2

Votre problème semble être avec boost::function - suivant les spécialisations de travail:
```
template <typename T>
T safeGuiCall()
{
    return T();
}

template <>
void safeGuiCall<void>()
{
}

int main() {
    int x = safeGuiCall<int>();     //ok
    //int z = safeGuiCall<void>();  //this should & does fail
    safeGuiCall<void>();            //ok
}
```
désolé essayé cela, mais ne fonctionne pas. Avez-vous compiler avec gcc? Je pense qu'il fonctionne sous VS par exemple...
C'est g++ version 3.4.5
C'est ce statiques - les supprimer et tout devrait être weel, il compile avec-comeau, je vais mettre à jour la réponse

OriginalL'auteur
1

J'ai eu un problème similaire. Si vous regardez le post original, j'ai quitté la première statique, mais a pris la deuxième et les DEUX erreurs s'en alla.

OriginalL'auteur Bob Belt

Vous devez vous connecter pour publier un commentaire.