วิธีรับแอดเดรสของฟังก์ชันแลมบ์ดา C ++ ภายในแลมบ์ดาเองได้อย่างไร

ฉันกำลังพยายามหาวิธีรับที่อยู่ของฟังก์ชันแลมบ์ดาภายในตัวเอง นี่คือตัวอย่างรหัส:

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

ฉันรู้ว่าฉันสามารถจับแลมบ์ดาในตัวแปรและพิมพ์ที่อยู่ได้ แต่ฉันต้องการทำสิ่งนี้เมื่อฟังก์ชันที่ไม่ระบุตัวตนกำลังดำเนินการ

มีวิธีที่ง่ายกว่านี้หรือไม่?

มันเป็นไปไม่ได้โดยตรง

อย่างไรก็ตามแลมบ์ดาจับเป็นชั้นเรียนและที่อยู่ของวัตถุเกิดขึ้นพร้อมกับที่อยู่ของสมาชิกคนแรกของมัน ดังนั้นหากคุณจับภาพวัตถุหนึ่งชิ้นตามค่าของการจับครั้งแรกที่อยู่ของการจับภาพครั้งแรกจะสอดคล้องกับที่อยู่ของวัตถุแลมบ์ดา:

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

ขาออก:

0x7ffe8b80d820
0x7ffe8b80d820

หรือคุณสามารถสร้างรูปแบบการออกแบบตกแต่งภายในแลมบ์ดาที่ส่งต่อการอ้างอิงไปยังการจับแลมบ์ดาในผู้ให้บริการโทรศัพท์:

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

ไม่มีวิธีรับที่อยู่ของวัตถุแลมบ์ดาโดยตรงภายในแลมบ์ดา

ตอนนี้มันเกิดขึ้นบ่อยครั้งมีประโยชน์มาก การใช้งานที่พบบ่อยที่สุดคือเพื่อที่จะเรียกคืน

y_combinatorมาจากภาษาที่คุณไม่สามารถพูดคุยเกี่ยวกับตัวคุณจนกว่าคุณที่กำหนดไว้ มันสามารถนำไปใช้งานได้อย่างง่ายดายใน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)... );
  }
};

ตอนนี้คุณสามารถทำได้:

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

รูปแบบของสิ่งนี้อาจรวมถึง:

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

โดยที่selfสามารถส่งผ่านโดยไม่ผ่านในselfฐานะอาร์กิวเมนต์แรก

ครั้งที่สองตรงกับ combinator y จริง (aka combinator จุดคงที่) ฉันเชื่อว่า ซึ่งคุณต้องการขึ้นอยู่กับความหมายของ 'address of lambda'

วิธีหนึ่งในการแก้ปัญหานี้คือการแทนที่แลมบ์ดาด้วยชั้นนักเขียนมือ มันเป็นสิ่งที่แลมบ์ดาเป็นสิ่งสำคัญ

จากนั้นคุณสามารถรับที่อยู่ผ่าน thisได้แม้ไม่เคยกำหนด functor ให้กับตัวแปร:

#include <iostream>

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

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

เอาท์พุท:

Address of this functor is => 0x7ffd4cd3a4df

นี่เป็นข้อดีที่พกพาได้ 100% และเหตุผลและเข้าใจง่าย

ยึดแลมบ์ดา:

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

เป็นไปได้ แต่ขึ้นอยู่กับแพลตฟอร์มและการปรับแต่งคอมไพเลอร์เป็นอย่างมาก

ในสถาปัตยกรรมส่วนใหญ่ที่ฉันรู้จักมีการลงทะเบียนที่เรียกว่าตัวชี้คำสั่ง จุดสำคัญของการแก้ปัญหานี้คือการดึงมันออกมาเมื่อเราอยู่ในฟังก์ชั่น

ใน amd64 รหัสต่อไปนี้ควรให้ที่อยู่ใกล้กับฟังก์ชันหนึ่ง

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

แต่สำหรับตัวอย่างใน gcc https://godbolt.org/z/dQXmHm ที่มี-O3ฟังก์ชั่นระดับการเพิ่มประสิทธิภาพอาจถูก inline