Jak uzyskać adres funkcji C ++ lambda w samej lambda?

Próbuję dowiedzieć się, jak uzyskać w sobie adres funkcji lambda. Oto przykładowy kod:

[]() {
    std::cout << "Address of this lambda function is => " << ????
}();

Wiem, że potrafię uchwycić lambda w zmiennej i wydrukować adres, ale chcę to zrobić w miejscu, gdy wykonuje się ta anonimowa funkcja.

Czy istnieje prostszy sposób na zrobienie tego?

Nie jest to bezpośrednio możliwe.

Jednak wartości lambda są klasami, a adres obiektu pokrywa się z adresem jego pierwszego elementu. Dlatego jeśli pierwszy obiekt zostanie przechwycony pod względem wartości, adres pierwszego przechwytywania odpowiada adresowi obiektu lambda:

int main() {
    int i = 0;
    auto f = [i]() { printf("%p\n", &i); };
    f();
    printf("%p\n", &f);
}

Wyjścia:

0x7ffe8b80d820
0x7ffe8b80d820

Alternatywnie można utworzyć wzór dekoracyjny lambda, który przekazuje odwołanie do przechwytywania lambda do operatora wywołania:

template<class F>
auto decorate(F f) {
    return [f](auto&&... args) mutable {
        f(f, std::forward<decltype(args)>(args)...);
    };
}

int main() {
    auto f = decorate([](auto& that) { printf("%p\n", &that); });
    f();
}

Nie ma bezpośredniego sposobu uzyskania adresu obiektu lambda w lambda.

Tak się składa, że ​​jest to często przydatne. Najczęstszym zastosowaniem jest powtórzenie.

y_combinatorPochodzi z języków, w których nie można było mówić o sobie, aż was gdzie zdefiniowane. Można go dość łatwo zaimplementować w c ++ :

template<class F>
struct y_combinator {
  F f;
  template<class...Args>
  decltype(auto) operator()(Args&&...args) const {
    return f( f, std::forward<Args>(args)... );
  }
  template<class...Args>
  decltype(auto) operator()(Args&&...args) {
    return f( f, std::forward<Args>(args)... );
  }
};

teraz możesz to zrobić:

y_combinator{ [](auto& self) {
  std::cout<<"Address of this lambda function is => "<< &self;
} }();

Odmiany tego mogą obejmować:

template<class F>
struct y_combinator {
  F f;
  template<class...Args>
  decltype(auto) operator()(Args&&...args) const {
    return f( *this, std::forward<Args>(args)... );
  }
  template<class...Args>
  decltype(auto) operator()(Args&&...args) {
    return f( *this, std::forward<Args>(args)... );
  }
};

gdzie selfprzekazany można wywołać bez podawania selfjako pierwszego argumentu.

Drugi odpowiada rzeczywistemu kombinatorowi y (czyli kombinatorowi punktu stałego). To, czego chcesz, zależy od tego, co rozumiesz przez „adres lambda”.

Jednym ze sposobów rozwiązania tego problemu byłoby zastąpienie lambda ręcznie napisaną klasą funktora. Właśnie to lambda zasadniczo znajduje się pod maską.

Następnie możesz uzyskać adres this, nawet bez przypisywania funktora do zmiennej:

#include <iostream>

class Functor
{
public:
    void operator()() {
        std::cout << "Address of this functor is => " << this;
    }
};

int main()
{
    Functor()();
    return 0;
}

Wynik:

Address of this functor is => 0x7ffd4cd3a4df

Ma to tę zaletę, że jest w 100% przenośne i niezwykle łatwe do uzasadnienia i zrozumienia.

Uchwyć lambda:

std::function<void ()> fn = [&fn]() {
  std::cout << "My lambda is " << &fn << std::endl;
}

Jest to możliwe, ale w dużym stopniu zależy od optymalizacji platformy i kompilatora.

W większości znanych mi architektur istnieje rejestr zwany wskaźnikiem instrukcji. Celem tego rozwiązania jest wyodrębnienie go, gdy jesteśmy w funkcji.

Na amd64 Poniższy kod powinien dać ci adresy zbliżone do funkcji 1.

#include <iostream>

void* foo() {
    void* n;
    asm volatile("lea 0(%%rip), %%rax"
      : "=a" (n));
    return n;
}

auto boo = [](){
    void* n;
    asm volatile("lea 0(%%rip), %%rax"
       : "=a" (n));
    return n;
};

int main() {
    std::cout<<"foo"<<'\n'<<((void*)&foo)<<'\n'<<foo()<<std::endl;  
    std::cout<<"boo"<<'\n'<<((void*)&boo)<<'\n'<<boo()<<std::endl;
}

Ale na przykład na gcc https://godbolt.org/z/dQXmHm z -O3funkcją poziomu optymalizacji może być wstawiony.