Напротив std:: bind, добавьте фиктивные параметры в функцию

Мне нужно что-то противоположное std:: bind, которое добавляет фиктивные параметры к сигнатуре функции, а не как boost:: bind связывает параметры.

например. У меня есть эта функция:

std::function<void (void)> myFunc;

Но я хочу преобразовать его в std::function<void(int)>, чтобы перейти к этой функции

void processFunction( std::function<void(int)> func);

Ответ 1

Изменить О, я упомянул очевидное в чате:

@EthanSteinberg: лямбда?
[] (int realparam, int dummy) { return foo(realparam); }

Но он был уволен, поэтому я прыгаю:

Изменить Я просто понял гораздо более простой подход: http://ideone.com/pPWZk

#include <iostream>
#include <functional>
using namespace std::placeholders;

int foo(int i)
{
    return i*2;
}

int main(int argc, const char *argv[])
{
    std::function<int(int, int)> barfunc = std::bind(foo, (_1, _2));
    std::cout << barfunc(-999, 21) << std::endl;

    // or even (thanks Xeo)
    barfunc = std::bind(foo, _2);
    std::cout << barfunc(-999, 21) << std::endl;
}

<суб >

Шаблоны Variadic http://ideone.com/8KIsW

Несколько более длительный ответ, основанный на вариационных шаблонах, привел бы к возможному меньшему коду на сайте вызова (если вы хотите обернуть функции длинным списком аргументов).

#include <iostream>
#include <functional>

int foo(int i)
{
    return i*2;
}

template <typename Ax, typename R, typename... A>
struct Wrap
{
    typedef R (*F)(A...);
    typedef std::function<R(A...)> Ftor;

    Wrap(F f) : _f(f) { }
    Wrap(const Ftor& f) : _f(f) { }

    R operator()(Ax extra, A... a) const
    { return _f(a...); /*just forward*/ }

    Ftor _f;
};

template <typename Ax=int, typename R, typename... A>
std::function<R(Ax, A...)> wrap(R (f)(A...))
{
    return Wrap<Ax,R,A...>(f);
}

template <typename Ax=int, typename R, typename... A>
std::function<R(Ax, A...)> wrap(std::function<R(A...)> functor)
{
    return Wrap<Ax,R,A...>(functor);
}

int main(int argc, const char *argv[])
{
    auto bar = wrap(foo);
    std::function<int(int, int)> barfunc = wrap(foo);

    std::cout << barfunc(-999, 21) << std::endl;

    // wrap the barfunc?
    auto rewrap = wrap(barfunc);
    std::cout << rewrap(-999, -999, 21) << std::endl;

    return 0;
}

Обобщение этого потребует более тяжелого подъема. Я думаю, что в прошлых помощниках я видел, как "анализировать" (используя метапрограммирование) подпись std:: function < > , и вы должны иметь возможность распознавать не-void-функции и, возможно, даже добавлять параметр в конце или в середине (сложно, насколько я могу сказать сейчас).

Но для вашего простого случая из OP это похоже, что вы охвачены

суб >

Ответ 2

Вы можете использовать лямбду, если ваша реализация поддерживает ее:

processFunction([=](int a){ myFunc(); });