有没有理由用右值引用重载运算符？

Question

有模板化的向量类（它是关于数学的，而不是容器）。我需要重载常见的数学运算。像这样重载是否有意义：

template <typename T, size_t D>
Vector<T, D> operator+(const Vector<T, D>& left, const Vector<T, D>& right)
{
    std::cout << "operator+(&, &)" << std::endl;
    Vector<T, D> result;

    for (size_t i = 0; i < D; ++i)
        result.data[i] = left.data[i] + right.data[i];

    return result;
}

template <typename T, size_t D>
Vector<T, D>&& operator+(const Vector<T, D>& left, Vector<T, D>&& right)
{
    std::cout << "operator+(&, &&)" << std::endl;
    for (size_t i = 0; i < D; ++i)
        right.data[i] += left.data[i];

    return std::move(right);
}

template <typename T, size_t D>
Vector<T, D>&& operator+(Vector<T, D>&& left, const Vector<T, D>& right)
{
    std::cout << "operator+(&&, &)" << std::endl;
    for (size_t i = 0; i < D; ++i)
        left.data[i] += right.data[i];

    return std::move(left);
}

使用此测试代码可以很好地工作：

auto v1 = math::Vector<int, 10>(1);
auto v2 = math::Vector<int, 10>(7);
auto v3 = v1 + v2;

printVector(v3);

auto v4 = v3 + math::Vector<int, 10>(2);

printVector(v4);

auto v5 = math::Vector<int, 10>(5) + v4;

printVector(v5);

//      ambiguous overload
//      auto v6 = math::Vector<int, 10>(100) + math::Vector<int, 10>(99);

并打印：

operator+(&, &)
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
operator+(&, &&)
10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 
operator+(&&, &)
15, 15, 15, 15, 15, 15, 15, 15, 15, 15,

两个右值引用有问题，但我认为这无关紧要。

为什么我要这样做？由于性能原因，理论上它会在不创建新对象的情况下运行得更快一点，但是会吗？也许编译器优化了简单的代码operator +(const Vector& left, const Vector& right)并且没有任何理由重载右值？

Answer 1

这取决于您的实施Vector：

• 如果类的移动速度比复制速度快，则为移动提供额外的重载可能会提高性能。
• 否则，提供重载的速度不应更快。

在评论中，您提到Vector看起来像这样：

template <typename T, size_t D>
class Vector
{
   T data[D];
   // ...
};

从您的代码中，我还假设这T是一个简单的算术类型（例如，float，int），其中复制与移动一样快。Vector<float, D>在这种情况下，您无法实现比复制操作更快的移动操作。

为了使移动操作比复制更快，您可以更改类的表示形式Vector。您可以存储指向数据的指针，而不是存储 C 数组，这样如果大小D很大，则可以更有效地进行移动操作。

打个比方，您当前的Vector实现就像 an std::array<T, D>（它内部保存一个 c 数组并且需要复制），但您可以切换到 an std::vector<T>（它保存指向堆的指针并且很容易移动）。该值越大，从D切换到 的吸引力就越大。std::arraystd::vector

让我们仔细看看为移动操作提供重载时的差异。

改进：就地更新

重载的优点是，您可以使用就地更新来避免在实现中必须为结果创建副本operator+(&,&)：

template <typename T, size_t D>
Vector<T, D> operator+(const Vector<T, D>& left, const Vector<T, D>& right)
{
    std::cout << "operator+(&, &)" << std::endl;
    Vector<T, D> result;

    for (size_t i = 0; i < D; ++i)
        result.data[i] = left.data[i] + right.data[i];

    return result;
}

在您的重载版本中，您可以就地更新：

template <typename T, size_t D>
Vector<T, D>&& operator+(const Vector<T, D>& left, Vector<T, D>&& right)
{
    std::cout << "operator+(&, &&)" << std::endl;
    for (size_t i = 0; i < D; ++i)
        right.data[i] += left.data[i];

    return std::move(right);
}

但是，当您使用 的当前实现时，移动结果将产生一个副本，而在非重载版本中，编译器可以使用返回值优化Vector来摆脱它。如果使用类似的表示，移动速度很快，因此就地更新版本应该比原始版本更快 ( )。std::vectoroperator+(&,&)

编译器可以自动进行就地更新优化吗？

如果没有帮助，编译器几乎不可能做到这一点。

在非重载版本中，编译器看到两个数组，它们是常量引用。它很可能能够执行返回值优化，但要知道它可以重用现有对象之一，需要编译器当时不具备的大量额外知识。

概括

从纯粹的性能角度来看，如果Vector移动速度比复制速度快，则为右值提供重载是合理的。如果移动速度不快，那么提供过载就没有任何好处。