Comment obtenir l'adresse d'une fonction lambda C ++ dans le lambda lui-même?

J'essaie de comprendre comment obtenir l'adresse d'une fonction lambda en elle-même. Voici un exemple de code:

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

Je sais que je peux capturer le lambda dans une variable et imprimer l'adresse, mais je veux le faire en place lorsque cette fonction anonyme s'exécute.

Existe-t-il un moyen plus simple de le faire?

Ce n'est pas directement possible.

Cependant, les captures lambda sont des classes et l'adresse d'un objet coïncide avec l'adresse de son premier membre. Par conséquent, si vous capturez un objet par valeur comme première capture, l'adresse de la première capture correspond à l'adresse de l'objet lambda:

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

Les sorties:

0x7ffe8b80d820
0x7ffe8b80d820

Vous pouvez également créer un modèle de conception de décorateur lambda qui transmet la référence à la capture lambda à son opérateur d'appel:

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

Il n'y a aucun moyen d'obtenir directement l'adresse d'un objet lambda dans un lambda.

Maintenant, comme cela arrive, cela est très souvent utile. L'usage le plus courant est pour soigner.

Le y_combinatorvient de langues où vous ne pouviez pas parler de vous jusqu'à ce que vous soyez défini. Il peut être implémenté assez facilement en 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)... );
  }
};

vous pouvez maintenant le faire:

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

Une variation de ceci peut inclure:

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

où le selfpassé peut être appelé sans passer selfcomme premier argument.

Le second correspond au vrai combinateur y (aka le combinateur à virgule fixe) je crois. Ce que vous voulez dépend de ce que vous entendez par «adresse de lambda».

Une façon de résoudre ce problème serait de remplacer le lambda par une classe de foncteurs manuscrite. C'est aussi ce que la lambda est essentiellement sous le capot.

Ensuite, vous pouvez obtenir l'adresse this, même sans jamais affecter le foncteur à une variable:

#include <iostream>

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

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

Production:

Address of this functor is => 0x7ffd4cd3a4df

Cela a l'avantage d'être 100% portable et extrêmement facile à raisonner et à comprendre.

Capturez le lambda:

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

C'est possible mais dépend fortement de la plateforme et de l'optimisation du compilateur.

Sur la plupart des architectures que je connais, il existe un registre appelé pointeur d'instruction. Le point de cette solution est de l'extraire lorsque nous sommes à l'intérieur de la fonction.

Sur amd64 Le code suivant devrait vous donner des adresses proches de celle de la fonction.

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

Mais par exemple sur gcc https://godbolt.org/z/dQXmHm avec la -O3fonction de niveau d'optimisation peut être intégrée.