有模板化的 vector 类(它是关于数学的,而不是容器)。我需要重载常见的数学运算。像这样重载有什么意义吗:
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)
优化简单代码,没有任何理由重载右值?
最佳答案
这取决于您对 Vector
的实现:
- 如果类的移动速度比复制速度快,则为移动提供额外的重载可能会提高性能。
- 否则,提供重载应该不会更快。
在评论中,您提到了 Vector
看起来像这样:
template <typename T, size_t D>
class Vector
{
T data[D];
// ...
};
根据您的代码,我还假设 T
是一种简单的算术类型(例如 float
、 int
),其中复制与移动一样快。在这种情况下,您无法为 Vector<float, D>
实现移动操作。这将比复制操作更快。
为了使移动操作比复制更快,您可以更改 Vector
的表示类(class)。您可以存储指向数据的指针,而不是存储 C 数组,如果大小为 D
,这将允许更有效的移动操作。很大。
打个比方,您当前的 Vector
实现就像一个 std::array<T, D>
(它内部包含一个 c 数组,需要复制),但您可以切换到 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+(&,&)
)。
编译器能否自动进行就地更新优化?
编译器极不可能在没有帮助的情况下完成它。
在非重载版本中,编译器看到两个数组,它们是常量引用。它很可能能够执行返回值优化,但要知道它可以重用现有对象之一,需要编译器此时不具备的大量额外知识。
总结
如果Vector
,从纯粹的性能角度来看,为右值提供重载是合理的移动比复制更快。如果移动速度不快,那么提供过载就没有好处。
关于c++ - 是否有任何理由使用右值引用来重载运算符?,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/45577319/