Как получить адрес лямбда-функции 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качестве первого аргумента.

Второе соответствует настоящему y комбинатору (он же комбинатор с фиксированной точкой), я считаю. То, что вы хотите, зависит от того, что вы подразумеваете под «адресом лямбды».

Один из способов решить эту проблему - заменить лямбду классом рукописных функторов. Это также то, что лямбда по сути находится под капотом.

Затем вы можете получить адрес this, даже не назначая функтор переменной:

#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функцией уровня оптимизации может быть встроено.