emballage de création d'objets pour une classe de modèle

Question

Étant donné une classe de modèle en tant que tel:

template <typename TYPE> 
class SomeClass { 
public: 
    typedef boost::intrusive_ptr<SomeClass<TYPE> > Client_t; 
    inline Client_t GetClient() { return Client_t(this); } 
}; 

SomeClass est destiné uniquement à être utilisé par des références de pointeur renvoyé par SomeClass :: getClient(). Ce qui le rend naturel d'écrire une fonction wrapper autour de la création comme ceci:

template <typename TYPE> 
SomeClass<TYPE>::Client_t New_SomeClass() { 
    return (new SomeClass<TYPE>)->GetClient(); 
} 

Compiler le code ci-dessus sous GCC 4.4:

SomeClass<int>::Client_t some_class = New_SomeClass(); 

donne l'erreur « New_SomeClass» n'a pas été déclaré dans ce champ » Maintenant je ne suis pas un assistant de gabarit, donc je ne suis pas au courant des détails, mais je suppose que je ne peux pas utiliser de construction de ce genre parce que C++ ne l'est pas. t autoriser une surcharge sur le type de retour.

Je suppose un ... frissonner ... macro serait le résoudre:

#define NEW_SOMECLASS(TYPE) ((new SomeClass<TYPE>)->GetClient()) 

auto some_class = NEW_SOMECLASS(int); 

Mais il doit y avoir un moyen raisonnable d'exposer la création d'objets d'une classe de modèle sans avoir recours à des macros ou autres constructions encombrantes?

Answer 1

SomeClass<int>::Client_t some_class = New_SomeClass<int>(); 

Parce que les paramètres de modèle pour New_SomeClass ne dépendent pas d'un paramètre de fonction, vous devez les spécifier. Le message d'erreur que vous avez signalé est un peu étrange pour ce problème, cependant, vous pourriez avoir quelque chose d'autre qui se passe.

Ou, ma préférence à la place de la fonction New_SomeClass:

template<class T> 
struct SomeClass { 
    typedef boost::intrusive_ptr<SomeClass> Client; 
    inline Client client() { return Client_t(this); } 

    static Client create() { return (new SomeClass())->client(); } 

private: 
    SomeClass(); // can be public too, if you really need it accessible 
}; 

//... 
SomeClass<int>::Client some_class = SomeClass<int>::create(); 

Même si elle ne fait que déplacer essentiellement la fonction « dans » la classe, je trouve généralement plus propre.

Dans tous les cas, si votre compilateur prend en charge « l'auto » de 0x vous pouvez l'utiliser:

auto some_class = SomeClass<int>::create(); 

Answer 2

vous pouvez essayer d'utiliser le type par défaut pour le paramètre de type de modèle