Surchage de paramètre non-type de modèle

Question

Est-il possible d'avoir deux classes de gabarit avec le même nom mais des paramètres de gabarits non-types différents - donc un type de mécanisme de surcharge de paramètre de gabarit non-type? La raison d'avoir un tel mécanisme est que les deux devraient pouvoir être créés en utilisant la même macro.

#define STORAGE(T, U, F) Storage<T, U, F> BOOST_PP_CAT(storage, __LINE__); 

STORAGE(Foo, bool, &Foo::foo) 
STORAGE(Bar, bool, &Bar::bar) 

Merci pour votre participation!

EDIT

peut être une entrée supplémentaire est utile.

Ce que je veux réaliser est une méthode à exécuter au moment de l'initialisation. Je peux fournir une telle méthode - ou mieux dit deux méthodes surchargées, une avec le const-ref et une avec la valeur-member-function-pointer; mais pour les exécuter au moment de l'initialisation, j'aurais habituellement une classe stub (comme Storage dans ce cas) qui appelle cette méthode dans son constructeur (et donc au moment de l'initialisation, car la macro STORAGE crée une instance de la classe stub). Pour utiliser la même macro STORAGE, je dois avoir le même modèle que les 'overloads' de type pour la classe stub que j'ai pour les fonctions à exécuter (et je vais devoir modéliser la classe et non le constructeur, qui Je pourrais certainement surcharger, car il n'est pas possible d'énoncer explicitement les paramètres du template du constructeur et comme les paramètres du template ne sont pas de type je ne peux pas les déduire aussi bien).

EDIT

Le pointeur de fonction membre doit être une valeur de temps de compilation (un paramètre de modèle non-types), tel qu'il sera enveloppé dans une méthode statique non-modèle, qui peut alors être stocké dans un vecteur std :: disponible à l'exécution.

Answer 1

Le problème que vous tentez de résoudre n'est pas entièrement clair. Si vous essayez simplement de faire fonctionner votre exemple, vous pouvez changer le 'bool' en 'const bool &'. Est-ce que cela réalise ce que vous vouliez?

template <typename T, typename U, void (T::*F)(U)> void common() { } 

struct Foo 
{ 
    void foo(bool) {} 
}; 

struct Bar 
{ 
    void bar(const bool &) {} 
}; 

template <typename T, typename U, void (T::*F)(U)> 
struct Storage 
{ 
     Storage() { common <T, U, F>(); } 
}; 

Storage<Foo, bool, &Foo::foo> foo; 
Storage<Bar, const bool&, &Bar::bar> bar;