Fonction semi-générique

Question

J'ai un tas de fonctions surchargées qui fonctionnent sur certains types de données tels que int, double et chaînes. La plupart de ces fonctions effectuent la même action, où seul un ensemble spécifique de types de données est autorisé. Cela signifie que je ne peux pas créer une simple fonction de modèle générique car je perds la sécurité de type (et potentiellement un problème d'exécution pour la validation au sein de la fonction).

Est-il possible de créer une "fonction de sécurité de type temps de compilation semi-générique"? Si c'est le cas, comment? Sinon, est-ce quelque chose qui apparaîtra en C++ 0x?

Une idée (non valide);

template <typename T, restrict: int, std::string > 
void foo(T bar); 
... 
foo((int)0); // OK 
foo((std::string)"foobar"); // OK 
foo((double)0.0); // Compile Error 

Note: Je me rends compte que je pouvais créer une classe qui a surchargé les constructeurs et les opérateurs d'affectation et de transmettre une variable de cette classe plutôt à la fonction.

Answer 1

Utilisez sfinae

template<typename> struct restrict { }; 
template<> struct restrict<string> { typedef void type; }; 
template<> struct restrict<int> { typedef void type; }; 

template <typename T> 
typename restrict<T>::type foo(T bar); 

Ce foo ne sera en mesure d'accepter ou stringint pour T. Aucune erreur de compilation dure ne se produit si vous appelez foo(0.f), mais plutôt s'il y a une autre fonction qui accepte l'argument, celui-ci est pris à la place.

Answer 2

Vous pouvez créer une fonction gabarit "privée" qui n'est jamais exposée à l'extérieur et l'appeler à partir de vos surcharges "sécurisées". D'ailleurs, il y a généralement le problème d'exposer directement la version modélisée: si le type passé n'est pas correct, une erreur de compilation sera émise (sauf si vous savez que votre algorithme peut exposer des bugs subtils avec certains types de données).).

Answer 3

Peut-être un peu solution laid, mais foncteurs pourrait être une option:

class foo { 
    void operator()(double); // disable double type 
public: 
    template<typename T> 
    void operator()(T bar) { 
     // do something 
    } 
}; 

void test() { 
    foo()(3); // compiles 
    foo()(2.3); // error 
} 

Edit: Je Inversed ma solution

class foo { 
    template<typename T> 
    void operator()(T bar, void* dummy) { 
    // do something 
    } 
public: 
    // `int` is allowed 
    void operator()(int i) { 
     operator()(i, 0); 
    } 
}; 

foo()(2.3); // unfortunately, compiles 
foo()(3); // compiles 
foo()("hi"); // error 

Answer 4

Vous pourriez probablement travailler avec des spécialisations des modèles pour le « restreint "types que vous voulez autoriser. Pour tous les autres types, vous ne fournissez pas de spécialisation de modèle, de sorte que le modèle générique "basic" sera utilisé. Là, vous pouvez utiliser quelque chose comme BOOST_STATIC_ASSERT pour lancer une erreur de compilation.

Voici quelques pseudo-code pour clarifier mon idée:

template <typename T> 
void foo(T bar) {BOOST_STATIC_ASSERT(FALSE);} 

template<> // specialized for double 
void foo(double bar) {do_something_useful(bar);}; 

Answer 5

Pour lister une sélection arbitraire de types je suppose que vous pourriez utiliser une typelist. E.g voir le last part of my earlier answer.

L'usage peut-être quelque chose comme:

//TODO: enhance typelist declarations to hide the recursiveness 
typedef t_list<std::string, t_list<int> > good_for_foo; 

template <class T> 
typename boost::enable_if<in_type_list<T, good_for_foo> >::type foo(T t);