2

考虑：

struct Foo {
    std::vector<int> data () const { return vec; }
    const std::vector<int>& c_data () const { return vec; }

    std::vector<int> vec {};
};

auto lambda1 = [] (const std::vector<int>&) {};
auto lambda2 = [] (std::vector<int>&&) {};

auto lambda3 = [] (const auto&) {};
auto lambda4 = [] (auto&& p) {};

用法是：

Foo f {};

lambda1 (f.data ());
lambda1 (f.c_data ());

lambda2 (f.data ());
lambda2 (f.c_data ()); // (X)

lambda3 (f.data ());
lambda3 (f.c_data ());

lambda4 (f.data ());
lambda4 (f.c_data ()); // (Y)

这段代码因为 (X) 而编译失败，这当然是我可以理解的。我们不能将 const 引用绑定到右值引用。美好的。

有人可以解释一下lambda4'sp参数的实际类型是什么吗？在这里（Y），即使我将 const 引用参数传递给它，编译器也会编译它。

类型推导意义上的lambda2和类型有什么区别？lambda4

4

1 回答 1

4 
auto lambda2 = [] (std::vector<int>&&) {};

这大致相当于：

struct __lambda2 {
    void operator()(std::vector<int>&& ) {}
} lambda2;

这里的调用操作符接受一个右值引用——它只接受右值。c_data()给你一个左值，因此编译器错误。

另一方面，

auto lambda4 = [] (auto&& p) {};

大致相当于：

struct __lambda4 {
    template <class T>
    void operator()(T&& ) {}
} lambda4;

T&&，其中T是模板参数，不是对推导类型的右值引用（即使它看起来像这样） - 它是转发引用。它可以同时接受左值和右值 - 并且会T根据两个值类别（T=std::vector<int>在第一次调用和T=std::vector<int> const&第二次调用中）进行不同的推断。由于它接受左值，因此没有编译错误。

请注意，转发引用只有形式T&&（用于模板参数T）和auto&&. 前任。：

template <class U>
struct X {
    template <class T> void foo(T&& );      // forwarding reference
    template <class T> void bar(T const&&); // rvalue reference to const T
    void quux(U&& );                        // rvalue reference to U
};
于 2016-03-17T16:21:45.087 回答