Làm thế nào để có được địa chỉ của hàm lambda C ++ trong chính lambda?

Tôi đang cố gắng tìm ra cách lấy địa chỉ của hàm lambda trong chính nó. Đây là một mã mẫu:

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

Tôi biết rằng tôi có thể chụp lambda trong một biến và in địa chỉ, nhưng tôi muốn thực hiện tại chỗ khi chức năng ẩn danh này đang thực thi.

Có cách nào đơn giản hơn để làm như vậy?

Nó không thể trực tiếp có thể.

Tuy nhiên, lambda chụp là các lớp và địa chỉ của một đối tượng trùng với địa chỉ của thành viên đầu tiên. Do đó, nếu bạn chụp một đối tượng theo giá trị là lần chụp đầu tiên, địa chỉ của lần chụp đầu tiên tương ứng với địa chỉ của đối tượng lambda:

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

Đầu ra:

0x7ffe8b80d820
0x7ffe8b80d820

Ngoài ra, bạn có thể tạo một mẫu lambda thiết kế trang trí chuyển tham chiếu đến phần bắt lambda vào toán tử cuộc gọi của nó:

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

Không có cách nào để trực tiếp lấy địa chỉ của một đối tượng lambda trong lambda.

Bây giờ, vì nó xảy ra điều này khá thường xuyên hữu ích. Việc sử dụng phổ biến nhất là để tái diễn.

Xuất y_combinatorphát từ các ngôn ngữ mà bạn không thể nói về bản thân mình cho đến khi bạn xác định được. Nó có thể được thực hiện khá dễ dàng trong 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)... );
  }
};

bây giờ bạn có thể làm điều này:

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

Một biến thể của điều này có thể bao gồm:

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

trong đó selfthông qua có thể được gọi mà không chuyển qua selflàm đối số đầu tiên.

Cái thứ hai khớp với bộ kết hợp y thực (hay còn gọi là bộ kết hợp điểm cố định) tôi tin. Những gì bạn muốn phụ thuộc vào những gì bạn có nghĩa là 'địa chỉ của lambda'.

Một cách để giải quyết điều này, sẽ là thay thế lambda bằng một lớp functor viết tay. Đó cũng là những gì lambda về cơ bản là dưới mui xe.

Sau đó, bạn có thể lấy địa chỉ thông qua this, thậm chí không bao giờ gán functor cho một biến:

#include <iostream>

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

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

Đầu ra:

Address of this functor is => 0x7ffd4cd3a4df

Điều này có lợi thế là đây là 100% di động, và cực kỳ dễ dàng để lý luận và hiểu.

Bắt lambda:

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

Có thể nhưng rất phụ thuộc vào nền tảng và tối ưu hóa trình biên dịch.

Trên hầu hết các kiến ​​trúc tôi biết, có thanh ghi được gọi là con trỏ lệnh. Điểm của giải pháp này là giải nén nó khi chúng ta ở trong hàm.

Trên amd64 Mã sau sẽ cung cấp cho bạn địa chỉ gần với chức năng một.

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

Nhưng ví dụ trên gcc https://godbolt.org/z/dQXmHm với -O3chức năng mức tối ưu hóa có thể được nội tuyến.