Wie erhalte ich die Adresse einer C ++ - Lambda-Funktion im Lambda selbst?

Ich versuche herauszufinden, wie man die Adresse einer Lambda-Funktion in sich selbst erhält. Hier ist ein Beispielcode:

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

Ich weiß, dass ich das Lambda in einer Variablen erfassen und die Adresse drucken kann, aber ich möchte es an Ort und Stelle tun, wenn diese anonyme Funktion ausgeführt wird.

Gibt es einen einfacheren Weg, dies zu tun?

Es ist nicht direkt möglich.

Lambda-Captures sind jedoch Klassen, und die Adresse eines Objekts stimmt mit der Adresse seines ersten Mitglieds überein. Wenn Sie also ein Objekt als erste Erfassung nach Wert erfassen, entspricht die Adresse der ersten Erfassung der Adresse des Lambda-Objekts:

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

Ausgänge:

0x7ffe8b80d820
0x7ffe8b80d820

Alternativ können Sie ein Dekorationsmuster Lambda erstellen , das den Verweis auf die Lambda-Erfassung an seinen Anrufoperator übergibt:

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

Es gibt keine Möglichkeit, die Adresse eines Lambda-Objekts innerhalb eines Lambda direkt abzurufen.

Nun, wie es passiert, ist dies ziemlich oft nützlich. Die häufigste Verwendung ist, um zu rekursieren.

Das y_combinatorkommt aus Sprachen, in denen Sie nicht über sich selbst sprechen konnten, bis Sie definiert wurden. Es kann ziemlich einfach in c ++ implementiert werden :

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

Jetzt können Sie dies tun:

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

Eine Variation davon kann umfassen:

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

wobei das selfübergebene aufgerufen werden kann, ohne selfals erstes Argument übergeben zu werden.

Der zweite entspricht dem Real-Y-Kombinator (auch bekannt als Fixpunkt-Kombinator), glaube ich. Was Sie wollen, hängt davon ab, was Sie unter "Lambda-Adresse" verstehen.

Eine Möglichkeit, dies zu lösen, besteht darin, das Lambda durch eine handgeschriebene Funktorklasse zu ersetzen. Es ist auch das, was das Lambda im Wesentlichen unter der Haube ist.

Dann können Sie die Adresse erhalten this, auch ohne den Funktor jemals einer Variablen zuzuweisen:

#include <iostream>

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

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

Ausgabe:

Address of this functor is => 0x7ffd4cd3a4df

Dies hat den Vorteil, dass dies zu 100% portabel ist und extrem einfach zu verstehen und zu verstehen ist.

Nehmen Sie das Lambda auf:

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

Dies ist möglich, hängt jedoch stark von der Plattform- und Compileroptimierung ab.

Auf den meisten mir bekannten Architekturen gibt es ein Register, das als Befehlszeiger bezeichnet wird. Der Sinn dieser Lösung besteht darin, sie zu extrahieren, wenn wir uns innerhalb der Funktion befinden.

Auf amd64 Der folgende Code sollte Ihnen Adressen in der Nähe der Funktion 1 geben.

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

Aber zum Beispiel auf gcc kann https://godbolt.org/z/dQXmHm mit -O3Optimierungsstufenfunktion inline sein.