无法将左值绑定到 A<Cv2>&&

Question

我认为通用引用 (T&&) 应该采用任何类型的引用。但是下面的不行。

当我试图在我正在编写的库中保持常量正确时，我运行遇到了这个问题。我是 C++ 的新手，以前从未见过这样的东西。

test.cpp:

enum Cv_qualifier {
    constant,
    non_const
};
template <Cv_qualifier Cv> class A;
template<>
class A<Cv_qualifier::constant> {
public:
    template<Cv_qualifier Cv2> 
    void t(const A<Cv2>&& out) {}
};

template <>
class A<Cv_qualifier::non_const> {
public:
    template<Cv_qualifier Cv2> 
    void t(const A<Cv2>&& out) {}
};

int main()
{
    A<Cv_qualifier::non_const> a;
    A<Cv_qualifier::constant> b;
    a.t(b);
}

错误（使用 g++ test.cpp -std=c++11 编译）：

test.cpp: In function ‘int main()’:
test.cpp:24:10: error: cannot bind ‘A<(Cv_qualifier)0u>’ lvalue to ‘const A<(Cv_qualifier)0u>&&’
     a.t(b);
          ^
test.cpp:17:10: note:   initializing argument 1 of ‘void A<(Cv_qualifier)1u>::t(const A<Cv2>&&) [with Cv_qualifier Cv2 = (Cv_qualifier)0u]’
     void t(const A<Cv2>&& out) {}
          ^

顺便说一句，在实际程序中，class A 不拥有任何实际数据，并且包含对实际保存数据的另一个 class 的引用。我希望这意味着当我允许 class A 的成员函数 t 接受临时对象时，我不会不断地创建 indirection/copy 数据。

Answer 1

通用引用，或转发引用，只因引用折叠而发生。它是这样工作的：

T&& & -> T&
T& && -> T&
T&& && -> T&&

这样，当您在模板函数中收到 T&& 时，右值引用可以根据 T 的类型折叠为其他类型的引用。在任何其他情况下，当折叠没有发生时，SomeType&& 将保持 SomeType&& 并且将是一个右值引用。

话虽如此，如果你想让你的函数支持转发，你可以这样做：

template <Cv_qualifier Cv> struct A;

template<>
struct A<Cv_qualifier::constant> {
    template<typename T> 
    void t(T&& out) {}
};

template <>
struct A<Cv_qualifier::non_const> {
    template<typename T> 
    void t(T&& out) {}
};

确实，现在崩溃发生了。如果你想从 T 中提取 Cv_qualifier 值，你可以让自己成为一个类型特征来做到这一点：

template<typename>
struct CvValue;

template<Cv_qualifier cv>
struct CvValue<A<cv>> {
    constexpr static Cv_qualifier value = cv;
};

然后，在你的函数中 t，你可以这样做：

//                   v----- This is a good practice to apply a constraint
template<typename T, std::void_t<decltype(CvValue<std::decay_t<T>>::value)>* = 0> 
auto t(T&& out) {
    constexpr auto cv = CvValue<std::decay_t<T>>::value;

    // do whatever you want with cv
}

如果你不会用C++17的std::void_t，你可以这样实现：

template<typename...>
using void_t = void;

但是，如果您只想测试 T 是否为 A<...>，请使用：

template<typename>
struct is_A : std::false_type {};

template<Cv_qualifier cv>
struct is_A<A<cv>> : std::true_type {};

别忘了，与std::decay_t一起使用：

template<typename T, std::enable_if_t<std::is_A<std::decay_t<T>>::value>* = 0> 
void t(T&& out) {}

无法将左值绑定到 A<Cv2>&&

Cannot bind lvalue to A<Cv2>&&

c++

constants

universal-reference