С ++ лямбда з захопленнями як покажчик функції

Я грав з лямбдами C ++ та їх неявним перетворенням на покажчики функцій. Мій початковий приклад - використання їх як зворотного виклику для функції ftw. Це працює, як очікувалося.

#include <ftw.h>
#include <iostream>

using namespace std;

int main()
{
    auto callback = [](const char *fpath, const struct stat *sb,
        int typeflag) -> int {
        cout << fpath << endl;
        return 0;
    };

    int ret = ftw("/etc", callback, 1);

    return ret;
}

Після модифікації, щоб використовувати захоплення:

int main()
{

    vector<string> entries;

    auto callback = [&](const char *fpath, const struct stat *sb,
        int typeflag) -> int {
        entries.push_back(fpath);
        return 0;
    };

    int ret = ftw("/etc", callback, 1);

    for (auto entry : entries ) {
        cout << entry << endl;
    }

    return ret;
}

Я отримав помилку компілятора:

error: cannot convert ‘main()::<lambda(const char*, const stat*, int)>’ to ‘__ftw_func_t {aka int (*)(const char*, const stat*, int)}’ for argument ‘2’ to ‘int ftw(const char*, __ftw_func_t, int)’

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

Чи є для цього обхідне рішення? Чи той факт, що їх не можна "неявно" перетворити, означає, що вони можуть "явно" перетворити? (Я спробував кастинг, але безуспішно). Що було б чистим способом модифікувати робочий приклад, щоб я міг додавати записи до якогось об’єкта за допомогою лямбда ?.

Оскільки для захоплення лямбд потрібно зберегти стан, насправді не існує простого "обхідного шляху", оскільки це не просто звичайні функції. Сенс щодо покажчика функції полягає в тому, що він вказує на єдину глобальну функцію, і ця інформація не має місця для стану.

Найближчим обхідним шляхом (який по суті відкидає стан) є надання певного типу глобальної змінної, до якої можна отримати доступ з вашої лямбда-функції. Наприклад, ви можете створити традиційний функторний об'єкт і надати йому функцію статичного члена, яка посилається на якийсь унікальний (глобальний / статичний) екземпляр.

Але це начебто розгромило всю мету захоплення лямбд.

Я просто зіткнувся з цією проблемою.

Код чудово компілюється без лямбда-захоплення, але при лямбда-захопленні існує помилка перетворення типу.

Рішення з C ++ 11 - використовувати std::function(редагувати: інше рішення, яке не вимагає модифікації підпису функції, показано після цього прикладу). Ви також можете використовувати boost::function(що насправді працює значно швидше). Приклад коду - змінено, щоб він компілювався, компілюється з gcc 4.7.1:

#include <iostream>
#include <vector>
#include <functional>

using namespace std;

int ftw(const char *fpath, std::function<int (const char *path)> callback) {
  return callback(fpath);
}

int main()
{
  vector<string> entries;

  std::function<int (const char *fpath)> callback = [&](const char *fpath) -> int {
    entries.push_back(fpath);
    return 0;
  };

  int ret = ftw("/etc", callback);

  for (auto entry : entries ) {
    cout << entry << endl;
  }

  return ret;
}

Редагувати: мені довелося переглянути це, коли я натрапив на застарілий код, де я не міг змінити оригінальний підпис функції, але все одно мав використовувати лямбди. Рішення, яке не вимагає модифікації підпису функції вихідної функції, наведено нижче:

#include <iostream>
#include <vector>
#include <functional>

using namespace std;

// Original ftw function taking raw function pointer that cannot be modified
int ftw(const char *fpath, int(*callback)(const char *path)) {
  return callback(fpath);
}

static std::function<int(const char*path)> ftw_callback_function;

static int ftw_callback_helper(const char *path) {
  return ftw_callback_function(path);
}

// ftw overload accepting lambda function
static int ftw(const char *fpath, std::function<int(const char *path)> callback) {
  ftw_callback_function = callback;
  return ftw(fpath, ftw_callback_helper);
}

int main() {
  vector<string> entries;

  std::function<int (const char *fpath)> callback = [&](const char *fpath) -> int {
    entries.push_back(fpath);
    return 0;
  };
  int ret = ftw("/etc", callback);

  for (auto entry : entries ) {
    cout << entry << endl;
  }

  return ret;
}

ОРИГІНАЛ

Лямбда-функції дуже зручні і зменшують код. У моєму випадку мені потрібні лямбди для паралельного програмування. Але це вимагає фіксації та функціонування покажчиків. Моє рішення тут. Але будьте обережні з обсягом змінних, які ви захопили.

template<typename Tret, typename T>
Tret lambda_ptr_exec(T* v) {
    return (Tret) (*v)();
}

template<typename Tret = void, typename Tfp = Tret(*)(void*), typename T>
Tfp lambda_ptr(T& v) {
    return (Tfp) lambda_ptr_exec<Tret, T>;
}

Приклад

int a = 100;
auto b = [&]() { a += 1;};
void (*fp)(void*) = lambda_ptr(b);
fp(&b);

Приклад із повернутим значенням

int a = 100;
auto b = [&]() {return a;};
int (*fp)(void*) = lambda_ptr<int>(b);
fp(&b);

ОНОВЛЕННЯ

Покращена версія

Минув деякий час з часу публікації першої публікації про лямбда-програму C ++ із захопленнями як покажчиком функції. Оскільки це було корисно для мене та інших людей, я дещо покращив.

Стандартна функція C вказівника api використовує умову void fn (void * data). За замовчуванням використовується ця умова, і лямбда-сигнал повинен оголошуватися аргументом void *.

Покращена реалізація

struct Lambda {
    template<typename Tret, typename T>
    static Tret lambda_ptr_exec(void* data) {
        return (Tret) (*(T*)fn<T>())(data);
    }

    template<typename Tret = void, typename Tfp = Tret(*)(void*), typename T>
    static Tfp ptr(T& t) {
        fn<T>(&t);
        return (Tfp) lambda_ptr_exec<Tret, T>;
    }

    template<typename T>
    static void* fn(void* new_fn = nullptr) {
        static void* fn;
        if (new_fn != nullptr)
            fn = new_fn;
        return fn;
    }
};

Приклад

int a = 100;
auto b = [&](void*) {return ++a;};

Перетворення лямбда-зйомки в покажчик C.

void (*f1)(void*) = Lambda::ptr(b);
f1(nullptr);
printf("%d\n", a);  // 101 

Може використовуватися і цим способом

auto f2 = Lambda::ptr(b);
f2(nullptr);
printf("%d\n", a); // 102

У випадку, якщо слід використовувати повернене значення

int (*f3)(void*) = Lambda::ptr<int>(b);
printf("%d\n", f3(nullptr)); // 103

І на випадок використання даних

auto b2 = [&](void* data) {return *(int*)(data) + a;};
int (*f4)(void*) = Lambda::ptr<int>(b2);
int data = 5;
printf("%d\n", f4(&data)); // 108

Використовуючи локально глобальний (статичний) метод, це можна зробити наступним чином

template <class F>
auto cify_no_args(F&& f) {
  static F fn = std::forward<F>(f);
  return [] {
    return fn();
  };
}

Припустимо, маємо

void some_c_func(void (*callback)());

Тож використання буде

some_c_func(cify_no_args([&] {
  // code
}));

Це працює, оскільки кожна лямбда має унікальний підпис, тому зробити її статичною не є проблемою. Далі наведено загальну обгортку з різною кількістю аргументів та будь-яким типом повернення, використовуючи той самий метод.

template <class F>
struct lambda_traits : lambda_traits<decltype(&F::operator())>
{ };

template <typename F, typename R, typename... Args>
struct lambda_traits<R(F::*)(Args...)> : lambda_traits<R(F::*)(Args...) const>
{ };

template <class F, class R, class... Args>
struct lambda_traits<R(F::*)(Args...) const> {
    using pointer = typename std::add_pointer<R(Args...)>::type;

    static pointer cify(F&& f) {
        static F fn = std::forward<F>(f);
        return [](Args... args) {
            return fn(std::forward<Args>(args)...);
        };
    }
};

template <class F>
inline lambda_traits<F>::pointer cify(F&& f) {
    return lambda_traits<F>::cify(std::forward<F>(f));
}

І подібне використання

void some_c_func(int (*callback)(some_struct*, float));

some_c_func(cify([&](some_struct* s, float f) {
    // making use of "s" and "f"
    return 0;
}));

Хе-хе - досить давнє запитання, але все ж ...

#include <iostream>
#include <vector>
#include <functional>

using namespace std;

// We dont try to outsmart the compiler...
template<typename T>
int ftw(const char *fpath, T callback) {
  return callback(fpath);
}

int main()
{
  vector<string> entries;

  // ... now the @ftw can accept lambda
  int ret = ftw("/etc", [&](const char *fpath) -> int {
    entries.push_back(fpath);
    return 0;
  });

  // ... and function object too 
  struct _ {
    static int lambda(vector<string>& entries, const char* fpath) {
      entries.push_back(fpath);
      return 0;
    }
  };
  ret = ftw("/tmp", bind(_::lambda, ref(entries), placeholders::_1));

  for (auto entry : entries ) {
    cout << entry << endl;
  }

  return ret;
}

Існує хакерський спосіб перетворити захоплюючу лямбду у покажчик на функцію, але при її використанні потрібно бути обережним:

/codereview/79612/c-ifying-a-capturing-lambda

Тоді ваш код виглядатиме так (попередження: компіляція мозку):

int main()
{

    vector<string> entries;

    auto const callback = cify<int(*)(const char *, const struct stat*,
        int)>([&](const char *fpath, const struct stat *sb,
        int typeflag) -> int {
        entries.push_back(fpath);
        return 0;
    });

    int ret = ftw("/etc", callback, 1);

    for (auto entry : entries ) {
        cout << entry << endl;
    }

    return ret;
}

Моє рішення, просто використовуйте покажчик на функцію для посилання на статичну лямбду.

typedef int (* MYPROC)(int);

void fun(MYPROC m)
{
    cout << m(100) << endl;
}

template<class T>
void fun2(T f)
{
    cout << f(100) << endl;
}

void useLambdaAsFunPtr()
{
    int p = 7;
    auto f = [p](int a)->int {return a * p; };

    //fun(f);//error
    fun2(f);
}

void useLambdaAsFunPtr2()
{
    int p = 7;
    static auto f = [p](int a)->int {return a * p; };
    MYPROC ff = [](int i)->int { return f(i); };
    //here, it works!
    fun(ff);
}

void test()
{
    useLambdaAsFunPtr2();
}

Знайшов відповідь тут: http://meh.schizofreni.co/programming/magic/2013/01/23/function-pointer-from-lambda.html

Він перетворює lambda pointerв void*і звернений назад , коли це необхідно.

1. до void*:

   auto voidfunction = новий тип declt (до_функції (лямбда)) (до_функції (лямбда));

2. від void*:

   автоматична функція = static_cast <std :: function *> (voidfunction);