Як отримати адресу функції 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функцією оптимізації рівня може бути накреслено.