c++ - std::forward 无限递归大小效应

Question

考虑以下代码:

class Test
{
  public:
    Test()
    {
    }

    Test(const Test &other) noexcept
    {
        *this = other;
    }

    Test(Test &&other) noexcept
    {
        *this = std::move(other);
    }

    auto operator = (const Test &other) noexcept -> Test&
    {
        // Make a copy of "other"
        // ...
        return *this;
    }

    auto operator = (Test &&other) noexcept -> Test&
    {
        // Move "other"
        // ...
        return *this;
    }
};

我想将移动和复制构造函数组合在一起。据我了解，可以像这样使用 std::forward 来实现:

template <class T>
Test(T &&other) noexcept
{
    *this = std::forward<T>(other);
}

如果小心使用，它看起来工作良好，如下所示:

Test test;
Test test1 { test };
Test test2 { std::move(test) };

另一方面，如果我尝试用不同于 Test 的类型值实例化一个 Test 对象，它会创建一个无限递归:

Test test { 1 }; // Creates an infinite recursion

有没有办法限制只有 Test 类型的 (r||l) 值的 Test 对象的实例化？

Answer 1

无限递归是由于Test的实例在赋值操作中被构造，需要再次调用构造函数。原因是您没有为 Test 以外的任何内容定义赋值运算符。

更准确地说，读这个:

template<typename T>
Test(T &&other)
{
    *this = forward<T>(other);
}

像这样:

template<typename T>
Test(T &&other)
{
    this->operator = (Test{forward<T>(other)}); // <- Recursion here
}

对于任何不是测试的T。

要解决这个问题，您需要定义一个适当约束的赋值运算符，如下所示:

template<typename T>
auto operator = (T &&value)
-> typename std::enable_if<
    ! std::is_same<typename std::decay<T>::type, Test>::value,
    Test &
    >::type
{
    // Assignment involving a T that is not a Test
    return *this;
}