C ++ lambda z przechwytywaniami jako wskaźnikiem funkcji


94

Bawiłem się lambdami C ++ i ich niejawną konwersją na wskaźniki funkcji. Moim początkowym przykładem było użycie ich jako wywołania zwrotnego dla funkcji ftw. Działa to zgodnie z oczekiwaniami.

#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;
}

Po zmodyfikowaniu go w celu użycia przechwytywania:

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;
}

Otrzymałem błąd kompilatora:

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)

Po lekturze. Dowiedziałem się, że lambdy używające przechwytywania nie mogą być niejawnie konwertowane na wskaźniki funkcji.

Czy istnieje obejście tego problemu? Czy fakt, że nie można ich „niejawnie” przekonwertować, oznacza, że ​​można je „jawnie” przekonwertować? (Próbowałem rzucać, ale bez powodzenia). Jaki byłby czysty sposób zmodyfikowania działającego przykładu, aby móc dołączyć wpisy do jakiegoś obiektu za pomocą lambd?


Jakiego kompilatora używasz? czy to VS10?
Ramon Zarazua B.

wersja gcc 4.6.1 20110801 [wersja gcc-4_6-branch 177033] (SUSE Linux)
duncan

4
Zwykle sposób przekazywania stanu w języku C do wywołań zwrotnych odbywa się za pośrednictwem dodatkowego argumentu do funkcji zwrotnej (zwykle typu void *). Jeśli używana biblioteka pozwala na ten dodatkowy argument, znajdziesz obejście tego problemu. W przeciwnym razie nie będziesz mieć możliwości osiągnięcia czysto tego, co chcesz zrobić.
Alexandre C.

Tak. Zdaję sobie sprawę, że interfejs API ftw.h i nftw.h jest wadliwy. Spróbuję fts.h
duncan

1
Świetny! /usr/include/fts.h:41:3: error: #error "<fts.h> nie może być używany z -D_FILE_OFFSET_BITS == 64"
duncan

Odpowiedzi:


48

Od przechwytywania lambdas trzeba zachować stan, nie jest naprawdę proste „obejście”, ponieważ są one nie tylko zwykłe funkcje. Punkt dotyczący wskaźnika funkcji polega na tym, że wskazuje on pojedynczą, globalną funkcję, a ta informacja nie ma miejsca na stan.

Najbliższym obejściem (które zasadniczo odrzuca stan) jest zapewnienie pewnego typu zmiennej globalnej, do której można uzyskać dostęp z poziomu lambda / funkcji. Na przykład, możesz stworzyć tradycyjny obiekt funktora i nadać mu statyczną funkcję składową, która odwołuje się do jakiejś unikalnej (globalnej / statycznej) instancji.

Ale to w pewnym sensie pokonuje cały cel przechwytywania lambd.


3
Bardziej przejrzystym rozwiązaniem jest umieszczenie lambdy wewnątrz adaptera przy założeniu, że wskaźnik funkcji ma parametr kontekstu.
Raymond Chen

4
@RaymondChen: Cóż, jeśli możesz określić, w jaki sposób funkcja ma być używana, to tak, to jest opcja. Chociaż w takim przypadku byłoby jeszcze łatwiej po prostu uczynić parametr argumentem samej lambdy!
Kerrek SB

3
@KerrekSB umieścił zmienne globalne w a namespacei oznacz je jako thread_local, to jest ftwpodejście, które wybrałem do rozwiązania czegoś podobnego.
Kjell Hedström

„wskaźnik funkcji wskazuje na pojedynczą, globalną funkcję, a ta informacja nie ma miejsca na stan”. -> Jak do cholery języki takie jak Java mogą to osiągnąć? Oczywiście, ponieważ ta pojedyncza, globalna funkcja jest tworzona w czasie wykonywania i osadza stan (a raczej odniesienie do niego) we własnym kodzie. Że jest cały punkt - nie powinno nie być pojedyncza, globalna funkcja ale wiele funkcji globalnych - po jednym dla każdego lambda jest używana w czasie wykonywania. Czy naprawdę w C ++ nie ma NIC, co to robi? (Myślałem, że std :: function jest stworzone dokładnie w tym jednym celu)
Dexter

1
@Dexter: errr .. krótka odpowiedź brzmi: nie, długa odpowiedź oznacza przeciążenie operatora. Niezależnie od tego, mój punkt widzenia się zgadza. Java to inny język, który nie jest tym samym, co C ++; Java nie ma wskaźników (ani przeciążalnych operatorów połączeń), a porównanie nie działa dobrze.
Kerrek SB

47

Właśnie napotkałem ten problem.

Kod kompiluje się dobrze bez przechwytywania lambda, ale podczas przechwytywania lambda występuje błąd konwersji typu.

Rozwiązaniem z C ++ 11 jest użycie std::function(edycja: inne rozwiązanie, które nie wymaga modyfikacji podpisu funkcji jest pokazane po tym przykładzie). Możesz także użyć boost::function(który faktycznie działa znacznie szybciej). Przykładowy kod - zmieniony tak, żeby się kompilował, skompilowany z 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;
}

Edycja: musiałem to ponownie odwiedzić, gdy natknąłem się na starszy kod, w którym nie mogłem zmodyfikować oryginalnej sygnatury funkcji, ale nadal potrzebowałem użyć lambd. Poniżej znajduje się rozwiązanie, które nie wymaga modyfikowania sygnatury funkcji oryginalnej funkcji:

#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;
}

73
Nie, to nie powinna być akceptowana odpowiedź. Nie chodzi o to, ftwaby wziąć std::functionzamiast wskaźnika funkcji ...
Gregory Pakosz

Drugie rozwiązanie zaproponowane w tej odpowiedzi rozwiązuje obawy @ gregory-pakosz poprzez zachowanie oryginalnego podpisu, ale nadal nie jest świetne, ponieważ wprowadza stan globalny. Gdyby ftwmiał argument void * userdata, wolałbym odpowiedź z @ evgeny-karpov.
duma

@prideout zgodził się - ja też nie lubię stanu globalnego. Niestety, zakładając, że podpis ftw nie może być modyfikowany i biorąc pod uwagę, że nie ma on void * userdata, stan musi być gdzieś przechowywany. Napotkałem ten problem, korzystając z biblioteki innej firmy. Będzie to działać dobrze, o ile biblioteka nie przechwyci wywołania zwrotnego i nie użyje go później, w którym to przypadku zmienna globalna działa po prostu jak dodatkowy parametr na stosie wywołań. Jeśli podpis ftw można zmodyfikować, wolałbym użyć std :: function zamiast void * userdata.
Jay West,

1
jest to niezwykle skomplikowane i użyteczne rozwiązanie, @Gregory powinienem powiedzieć „to działa”.
fiorentinoing

17

ORYGINAŁ

Funkcje lambda są bardzo wygodne i redukują kod. W moim przypadku potrzebowałem lambd do programowania równoległego. Ale wymaga przechwytywania i wskaźników funkcji. Moje rozwiązanie jest tutaj. Uważaj jednak na zakres zmiennych, które przechwyciłeś.

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>;
}

Przykład

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

Przykład ze zwracaną wartością

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

AKTUALIZACJA

Poprawiona wersja

Minęło trochę czasu od opublikowania pierwszego postu o lambdzie w C ++ z przechwytywaniami jako wskaźnikiem funkcji. Ponieważ był użyteczny dla mnie i innych osób, dokonałem pewnej poprawy.

Standardowy interfejs API funkcji C używa konwencji void fn (void * data). Domyślnie używana jest ta konwencja, a lambda należy zadeklarować z argumentem void *.

Ulepszona implementacja

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;
    }
};

Exapmle

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

Konwersja lambda z przechwytywaniami do wskaźnika C.

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

Może być również używany w ten sposób

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

W przypadku, gdy należy użyć wartości zwracanej

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

I w przypadku wykorzystania danych

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

3
Jest to zdecydowanie najwygodniejsze rozwiązanie, jakie widziałem, aby przekonwertować lambdę na wskaźnik funkcji w stylu C. Funkcja przyjmująca go jako argument będzie potrzebować tylko dodatkowego parametru reprezentującego jej stan, często nazywanego „void * user” w bibliotekach C, aby mogła przekazać go do wskaźnika funkcji podczas jej wywoływania.
Codoscope

10

Używając lokalnie globalnej (statycznej) metody można to zrobić w następujący sposób

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

Załóżmy, że mamy

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

Więc użycie będzie

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

To działa, ponieważ każda lambda ma unikalną sygnaturę, więc uczynienie jej statyczną nie stanowi problemu. Poniżej znajduje się ogólne opakowanie z różną liczbą argumentów i dowolnym typem zwracanym przy użyciu tej samej metody.

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));
}

I podobne użycie

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;
}));

1
pamiętaj, że to skopiuje zamknięcie (podczas pobierania ptr) + args (podczas wywoływania). W przeciwnym razie jest to eleganckie rozwiązanie
Ivan Sanz-Carasa

biblioteka pomocnicza tylko dla nagłówka: gist.github.com/isc30/fab67e5956fe8f2097bed84ebc42c1e8
Ivan Sanz-Carasa

1
@ IvanSanz-Carasa Dzięki za zwrócenie uwagi. Typy zamknięć nie są CopyAssignable, ale funktory. Więc masz rację, lepiej jest tutaj użyć idealnego przekazywania. Z drugiej strony dla argumentów nie możemy wiele zrobić, ponieważ zwykły C nie obsługuje uniwersalnych odwołań, ale przynajmniej możemy przekazać wartości z powrotem do naszej lambdy. Może to zaoszczędzić dodatkową kopię. Edytował kod.
Vladimir Talybin

@RiaD Tak, ponieważ lambda jest tutaj statyczną instancją, musisz zamiast tego przechwycić przez odniesienie, np. Zamiast =używać &iw pętli for.
Vladimir Talybin

5

Hehe - dość stare pytanie, ale wciąż ...

#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;
}

0

Istnieje hakerski sposób na przekonwertowanie przechwytywanej lambdy na wskaźnik funkcji, ale podczas jej używania należy zachować ostrożność:

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

Twój kod wyglądałby wtedy tak (ostrzeżenie: kompilacja mózgu):

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;
}

0

Moje rozwiązanie, po prostu użyj wskaźnika funkcji, aby odwołać się do statycznej lambdy.

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();
}

Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.