丢弃限定符未知原因（std：：bind（）/lambda）

Question

我不明白资格赛在哪里/为什么会被淘汰。

#include <iostream>
#include <memory>

class A {
public:
    void f() {};
};

template <typename Callable>
void invoker(Callable c) {
    auto l = [=]() {
        c(); // <------------------- Error
    };
    l();
}

int main() {
    A a;
    invoker(std::bind(&A::f, a));
    return 0;
}

我在c（）上得到一个编译器错误；生产线：

错误：传递“const std:：\u Bind（A）

解决方法我不明白：

>

将A：：f（）定义为const:void f（）const{}；

bind（）对实例a的引用：调用者（std::bind（

通过以下方式传递到lambda：自动l=[

g版本：

g++ --version
g++ (Ubuntu 4.8.4-2ubuntu1~14.04.3) 4.8.4

Answer 1

霍尔特的回答很好。

如果不能将a：：f修改为常量方法，则可以使lambda可变：

#include <iostream>
#include <memory>
#include <functional>

class A {
public:
    void f() {};
};

template <typename Callable>
void invoker(Callable c) {
    auto l = [=]() mutable // <-- Fixed
    {
        c(); 
    };
    l();
}

int main() {
    A a;
    invoker(std::bind(&A::f, a));
    return 0;
}

Answer 2

据此：

std::bind的返回类型包含std::decay类型的成员对象

这意味着c持有a的副本（我们称之为c.a），但由于您是通过副本捕获c，因此c在lambda中是限定的，调用

• 通过生成成员函数，可以在对象上调用它

额外的细节（仍然来自这里）：

如果存储的参数arg的类型是std::reference_wrapper

因此，使用std：：ref（a）调用相当于：

std::invoke(&A::f, std::forward<A&>(c_a.get()));

其中，c\U a是std：：reference\U包装

否则，普通存储的参数arg作为左值参数传递给可调用对象：上面调用std：：invoke中的参数vn是简单的arg，相应的类型vn是cv

因此，原始调用等效于（因为c是常量，所以cv是常量）：

std::invoke(&A::f, std::forward<A const&>(c_a));

其中，c\U a是c中a的副本。