是否有任何理由使用右值引用来重载运算符?

Is there any reason to overload operators with rvalue reference?

有模板化向量class(这是关于数学,而不是容器)。我需要重载常见的数学运算。像这样重载有什么意义吗:

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) 优化简单代码,没有任何理由重载右值?

如果你的向量移动比复制更便宜(通常情况下,它在内部存储指向可以廉价复制的数据的指针),那么为 rvlaue 引用重载将有助于提高性能。您可以查看 std::string 以及它如何在此处的两个参数中为所有可能的引用重载:http://en.cppreference.com/w/cpp/string/basic_string/operator%2B

编辑

由于 OP 阐明了内部数据表示是 c 样式数组,因此提供多个重载没有任何好处。 C 风格的数组不能廉价地移动 - 它们被复制 - 所以那些多重重载没有任何用处。

这取决于你的实施 Vector:

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

在评论中,您提到 Vector 看起来像这样:

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

根据您的代码,我还假设 T 是一种简单的算术类型(例如,floatint),其中复制与移动一样快。在这种情况下,您无法为 Vector<float, D> 实施比复制操作更快的移动操作。

为了使移动操作比复制更快,您可以更改 Vector class 的表示。您可以存储指向数据的指针,而不是存储 C 数组,如果大小 D 很大,这将允许更有效的移动操作。

作为类比,您当前的 Vector 实现就像一个 std::array<T, D> (which holds internally a c-array and needs to be copied), but you could switch to an std::vector<T>(它包含指向堆的指针并且易于移动)。 D的值越大,应该从std::array切换到std::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 实现时,移动结果将产生一个副本,而在非重载版本中,编译器可以使用 return-value optimization 删除它。如果你用std::vector这样的表示,移动很快,所以就地更新版本应该比原来的版本快(operator+(&,&))。

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

编译器在没有帮助的情况下不太可能做到这一点。

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

总结

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