Come ottenere l'indirizzo di una funzione lambda C ++ all'interno della stessa lambda?

Sto cercando di capire come ottenere l'indirizzo di una funzione lambda all'interno di se stesso. Ecco un codice di esempio:

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

So che posso catturare la lambda in una variabile e stampare l'indirizzo, ma voglio farlo sul posto quando questa funzione anonima è in esecuzione.

C'è un modo più semplice per farlo?

Non è direttamente possibile.

Tuttavia, le acquisizioni lambda sono classi e l'indirizzo di un oggetto coincide con l'indirizzo del suo primo membro. Pertanto, se si acquisisce un oggetto in base al valore come prima acquisizione, l'indirizzo della prima acquisizione corrisponde all'indirizzo dell'oggetto lambda:

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

Uscite:

0x7ffe8b80d820
0x7ffe8b80d820

In alternativa, puoi creare un modello di disegno del decoratore lambda che passa il riferimento all'acquisizione lambda nel suo operatore di chiamata:

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

Non è possibile ottenere direttamente l'indirizzo di un oggetto lambda all'interno di un lambda.

Ora, come succede, questo è abbastanza spesso utile. L'uso più comune è per ricorrere.

Il y_combinatorproviene dalle lingue in cui non si poteva parlare di te fino a quando non dove definito. Può essere implementato abbastanza facilmente in 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)... );
  }
};

ora puoi farlo:

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

Una variante di questo può includere:

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

dove il selfpassato può essere chiamato senza passare selfcome primo argomento.

Il secondo corrisponde al combinatore reale y (alias il combinatore a punto fisso) credo. Quello che vuoi dipende da cosa intendi per "indirizzo di lambda".

Un modo per risolvere questo problema sarebbe quello di sostituire la lambda con una classe di funzioni scritta a mano. È anche ciò che la lambda è essenzialmente sotto il cofano.

Quindi puoi ottenere l'indirizzo this, anche senza mai assegnare il functor a una variabile:

#include <iostream>

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

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

Produzione:

Address of this functor is => 0x7ffd4cd3a4df

Ciò ha il vantaggio di essere portatile al 100% ed estremamente facile da ragionare e comprendere.

Cattura la lambda:

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

È possibile ma dipende fortemente dall'ottimizzazione della piattaforma e del compilatore.

Sulla maggior parte delle architetture che conosco, esiste un registro chiamato puntatore alle istruzioni. Il punto di questa soluzione è estrarlo quando siamo all'interno della funzione.

Su amd64 Il codice seguente dovrebbe fornire indirizzi vicini a quello della funzione.

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

Ma per esempio su gcc https://godbolt.org/z/dQXmHm con -O3funzione di livello di ottimizzazione potrebbe essere inline.