Отправка для двоичных и унарных вызовов в C++03

Question

У меня проблемы с реализацией этого в устаревшем C++, но я почти уверен, что это можно сделать. Скажем, у меня есть функция более высокого порядка, для которой нужны две версии, одна для унарных функций (объекты-функции, функции, функции-члены)

template <class F>
void ho_fun(F argFun) { 
    int arg1; 
    argFun(arg1); 
}

и один для двоичного:

template <class F>
void ho_fun(F argFun) { 
    int arg1, arg2; 
    argFun(arg1, arg2); 
}

Я ищу полное решение в терминах "вызываемого типа" (в противном случае я бы, очевидно, использовал для этого arity из признаков функции), то есть поддержку функций и функциональных объектов.

Я перевожу этот прекрасный пост на C++03 (удалить ... а также using typedefs) но это не похоже на работу.

PS. Я не решаю конкретную проблему, перечисленную выше, это просто sscce. Также я упоминаю C++ 03, потому что я работаю над унаследованным кодом для этого проекта, и современное решение для меня бесполезно. Безусловно, не стесняйтесь размещать современные, но, пожалуйста, подумайте и о помощи мне.

Answer 1

Этот ответ дает решение вопроса, который, как я понимаю, вы задаете:

Как я могу специализировать функцию, чтобы она могла определять, является ли ее аргумент унарной или двоичной функцией, методом или функтором?

В C++03 ваш единственный вариант - написать специализацию для каждого из них, и, между прочим, вам нужно будет сделать специализацию для const методы, а такжеconst методы:

template <typename Arg, typename Result>
void ho_fun(Result(*argFun)(Arg)) {
    Arg arg = 13;

    argFun(arg);
}

template <typename Arg1, typename Arg2, typename Result>
void ho_fun(Result (*argFun)(Arg1, Arg2)) {
    Arg1 arg1 = 13;
    Arg2 arg2 = 42;

    argFun(arg1, arg2);
}

template <typename T, typename Arg, typename Result>
void ho_fun(Result(T::*argFun)(Arg)) {
    T myClass;
    Arg arg = 13;

    (myClass.*argFun)(arg);
}

template <typename T, typename Arg1, typename Arg2, typename Result>
void ho_fun(Result(T::*argFun)(Arg1, Arg2)) {
    T myClass;
    Arg1 arg1 = 13;
    Arg2 arg2 = 42;

    (myClass.*argFun)(arg1, arg2);
}

template <typename T, typename Arg, typename Result>
void ho_fun(Result(T::*argFun)(Arg) const) {
    T myClass;
    Arg arg = 13;

    (myClass.*argFun)(arg);
}

template <typename T, typename Arg1, typename Arg2, typename Result>
void ho_fun(Result(T::*argFun)(Arg1, Arg2) const) {
    T myClass;
    Arg1 arg1 = 13;
    Arg2 arg2 = 42;

    (myClass.*argFun)(arg1, arg2);
}

template <class T>
void ho_fun(T argFun) {
    ho_fun(&T::operator());
}

Живой пример