Параметр непигового шаблона ... это шаблон! (C++)

Question

Я в основном ищу для создания обертки для общей функции C без необходимости вручную указывать типы. Поэтому у меня есть обратный вызов с фиксированным прототипом, но мне нужно будет сделать специальный код в оболочке на основе типа завернутой функции ... Поэтому в основном я думаю об использовании статического метода в шаблоне класса обернуть функцию в соответствующем интерфейсе, например:

// this is what we want the wrapped function to look like 
typedef void (*callback)(int); 
void foobar(float x); // wrappee 

// doesn't compile 
template< T (*f)(S) > // non-type template param, it's a function ptr 
struct Wrapper 
{ 
    static void wrapped(int x) 
    { 
    // do a bunch of other stuff here 
    f(static_cast<S>(x)); // call wrapped function, ignore result 

    } 
} 

и тогда я хотел бы сделать что-то вроде:

AddCallback(Wrapper<foobar>::wrapped); 

Однако, проблема в том, что я не могу просто идти вперед и использовать «S» в параметре функции в шаблоне Wrapper, я должен сначала перечислить его как параметр:

template< class T, class S, T (*f)(S) > 
struct Wrapper 
// ... 

Но это означает, что гораздо больнее использовать (Wrapper<void,float,foobar>::wrapped), в идеале я хотел бы просто передать указатель функции там, и он автоматически будет обрабатывать типы параметров (и возвращаемых типов). Чтобы быть ясным, внутри завернутой функции мне нужно будет обратиться к типам указателя функции (так что мне нужен какой-то эквивалент S или T).

Есть ли способ сделать это?

Answer 1

Если вы используете функцию, которая возвращает «завернутый», а не ссылается на нее напрямую, компилятор попытается автоматически сопоставить параметры шаблона для вызова функции.

Редактировать: Как насчет этого?

int foobar(float x); // wrappee 

template <typename T, typename S> 
struct Wrapper { 
    typedef T (*F)(S); 
    F f; 

    Wrapper(F f) : f(f) { } 

    void wrapped(S x) { 
     // do a bunch of other stuff here 
     f(x); // call wrapped function, ignore result 
    } 
}; 

template <typename T, typename S> 
Wrapper<T,S> getWrapper(T (*f)(S)) { 
    return Wrapper<T,S>(f); 
} 

... 
getWrapper(foobar).wrapped(7); 

Answer 2

EDIT: совершенно новый ответ

ОК, я полностью повторно думал вопрос и считаю, что я получаю то, что вы хотите. Я сделал это раньше: -P.

Вот идея, у меня есть класс Base, который перегружает operator(), тогда у меня есть подкласс для каждой «arity» функций. Наконец, у меня есть заводская функция, которая вернет одну из этих вещей. Код большой (и, вероятно, немного перебор), но работает красиво. Большая часть перегрузок library_function предназначена для поддержки разных синтаксисов, в основном ненужных. Он также поддерживает функции boost::bind, функции-члены и т. Д., Намного больше, чем вам, вероятно, нужно.

http://pastebin.com/m35af190

Пример, использование:

// map of library functions which will return an int. 
std::map<std::string, LibraryFunction<int> > functions; 

// function to register stuff in the map 
void registerFunction(const std::string &name, LibraryFunction<int> func) { 
    functions.insert(std::make_pair(name, func)); 
} 

позже вы можете сделать это:

// the this param is so the function has access to the scripting engine and can pop off the parameters, you can easily chop it out 

// register 2 functions, one with no params, one with 1 param 
registerFunction("my_function", library_function1(*this, call_my_function)); 
registerFunction("my_function2", library_function0(*this, call_my_function2)); 

functions["my_function"](); 
functions["my_function2"](); 

Answer 3

Я смотрел на импульс. При первом чтении вашего вопроса мне кажется, что <boost/function_types/parameter_types.hpp> предоставляет то, что вам нужно.

Answer 4

Одна вещь, которую вы, возможно, захотите рассмотреть, - это использование LLVM или аналогичного для создания соответствующей функции батута во время выполнения.Или вот статическое решение:

#include <iostream> 

void f(float f) { std::cout << f << std::endl; } 

template<typename T, typename S> struct static_function_adapter { 
     template<T(*f)(S)> struct adapt_container { 
       static void callback(int v) { 
         f(static_cast<S>(v)); 
       } 
     }; 

     template<T(*f)(S)> adapt_container<f> adapt() const { 
       return adapt_container<f>(); 
     } 
}; 

template<typename T, typename S> struct static_function_adapter<T, S> get_adapter(T (*)(S)) { 
     return static_function_adapter<T, S>(); 
} 

#define ADAPTED_FUNCTION(f) (&get_adapter(f).adapt<f>().callback) 

int main() { 
     void (*adapted)(int) = ADAPTED_FUNCTION(f); 
     adapted(42); 
     return 0; 
} 

Функция get_adapter позволяет нам вывести аргумент и тип возвращаемого значения; adapt() затем преобразует это в тип, параметризованный по фактической функции, и, наконец, мы получаем статическую функцию в обратном вызове.