la production d'foncteur de membre de type pointeur de fonction

Question

Je suis en train de simplifier (via make_fn()) la génération de foncteurs que les paramètres prétraiter (via wrap()) pour les fonctions membres de arity n .
Génération foncteurs travaille essentiellement, mais jusqu'à présent uniquement en spécifiant explicitement les types de paramètres pour la fonction de membre.
Maintenant, je voudrais générer le foncteur correct du type de fonction membre il gère:

struct X {};

template<class C, typename T1, bool (C::*F)(T1)>
inline // there are more for T1..TN
bool wrap(C* c, X x) 
{
    return (c->*F)(process<T1>(x));
}

template<class C, typename T1, bool (C::*F)(T1)> 
inline // there are more for T1..TN
boost::function<bool (C*, X)> make_fn(F f) // <- problem here, F is not a type
{
    return boost::bind(&wrap<C, T1, F>, _1, _2);
}

Avec cela, cependant, vc ++ et g ++ ne voient pas F comme type pour le paramètre de make_fn(). Je dois manquer ici quelque chose d'évident et je me sens un peu aveugle.

L'idée était que cela devrait fonctionner comme ceci:

struct A 
{
    bool f1(bool) { return true; }
};

void test()
{
    A a;
    X x;
    make_fn(&A::f1)(&a, x);
}

Toutes les idées sur la façon de faire ce travail?

Contexte: J'ai une interface fixe qui, lorsqu'elle est simplifiée, ressemble à ceci:

bool invoke(C* c, const char* const functionName, int argCount, X* args);

X est un type de variante que je dois convertir certains types de back-end (int, std :: string, ...).
Pour gérer ces appels que j'ai une carte de foncteurs qui sont recherchés par leur nom et la carte de ces appels à des fonctions de membre d'une instance.
L'intention de l'emballage est d'éviter les conversions manuelles et au lieu de générer foncteurs qui font la conversion pour moi ou throw. J'ai ce travail avec une solution à base de macro, mais cette solution nécessite de spécifier les types et le paramètre compte explicitement.
Via la résolution de surcharge de la fonction i espère générer le foncteur correcte conversion implicite de la signature de la fonction de membre.

Answer 1

Il me semble que vous essayez de mettre un pointeur passé à une fonction dans un argument de modèle non de type, que j'ai peur ne va pas travailler (voir les commentaires à votre question).

Qu'est-ce que vous pourriez faire, est de stocker le pointeur de fonction dans un objet de fonction. Ce qui suit semble compiler:

#include <boost/bind.hpp>
#include <boost/function.hpp>

struct X {};

template <class T>
bool process(X) { return true; }


template <class C, class T1, class Func>
struct wrap1
{
    typedef bool result_type;
    Func f;

    wrap1(Func f): f(f) {}

    bool operator()(C* c, X x)
    {
        return (c->*f)(process<T1>(x));
    }
};

template<class C, typename T1>
inline // there are more for T1..TN
boost::function<bool (C*, X)> make_fn(bool (C::*f)(T1))
{
    return boost::bind(wrap1<C, T1, bool (C::*)(T1)>(f), _1, _2);
}


struct A
{
    bool f1(bool) { return true; }
};

void test()
{
    A a;
    X x;
    make_fn(&A::f1)(&a, x);
}

Cependant, je ne suis pas sûr que ce soit une bonne et comment vous devez créer le reste des emballages. Pour ce dernier, vous pourriez obtenir un compilateur qui prend en charge les modèles variadique. :)