Lambda'nın kendisinde bir C ++ lambda fonksiyonunun adresi nasıl alınır?

Kendi içinde bir lambda fonksiyonunun adresini nasıl alacağımı anlamaya çalışıyorum. İşte bir örnek kod:

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

Lambda'yı değişken olarak yakalayabildiğimi ve adresi yazdırabileceğimi biliyorum, ancak bu anonim işlev yürütülürken yerinde yapmak istiyorum.

Bunu yapmanın daha basit bir yolu var mı?

Doğrudan mümkün değil.

Bununla birlikte, lambda yakalamaları sınıflardır ve bir nesnenin adresi ilk üyesinin adresi ile çakışır. Dolayısıyla, bir nesneyi ilk yakalama olarak değere göre yakalarsanız, ilk yakalamanın adresi lambda nesnesinin adresine karşılık gelir:

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

Çıktılar:

0x7ffe8b80d820
0x7ffe8b80d820

Alternatif olarak, lambda yakalamasına başvuruyu çağrı operatörüne aktaran bir dekoratör tasarım deseni lambda oluşturabilirsiniz:

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

Lambda içindeki lambda nesnesinin adresini doğrudan almanın bir yolu yoktur.

Şimdi, olduğu gibi, bu genellikle yararlıdır. En yaygın kullanım, tekrarlamaktır.

y_combinatorTanımlanmış nerede sizin kadar kendine konuşamadık dillerden gelir. C ++ ile kolayca uygulanabilir :

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

şimdi bunu yapabilirsiniz:

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

Bunun bir varyasyonu şunları içerebilir:

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

Burada selfgeçilen selfilk argüman olarak geçmeden çağrılabilir .

İkincisi, gerçek y birleştiriciyle (sabit nokta birleştiricisi olarak da bilinir) eşleştiğine inanıyorum. Hangisini istediğiniz 'lambda adresi' ile ne demek istediğinize bağlıdır.

Bunu çözmenin bir yolu, lambda'yı elle yazılmış bir functor sınıfıyla değiştirmek olacaktır. Aynı zamanda lambda'nın aslında kaputun altında olduğu şey.

Daha sonra, işlevi thisbir değişkene atamadan bile adresi alabilirsiniz :

#include <iostream>

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

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

Çıktı:

Address of this functor is => 0x7ffd4cd3a4df

Bunun avantajı,% 100 taşınabilir olması ve akıl yürütmesi ve anlaması son derece kolaydır.

Lambda'yı yakalayın:

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

Mümkün ancak platform ve derleyici optimizasyonuna bağlı.

Bildiğim mimarilerin çoğunda, talimat işaretçisi adı verilen bir kayıt var. Bu çözümün amacı, fonksiyonun içindeyken onu çıkarmaktır.

Amd64 üzerinde Aşağıdaki kod size bir işleve yakın adresler vermelidir.

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

Ancak, örneğin optimizasyon seviyesi işlevine sahip gcc https://godbolt.org/z/dQXmHm üzerinde -O3satır içi olabilir.