1

我正在尝试遵循 Scott Meyers 在更有效 C++ 的第 22 项中的建议：“考虑使用op=而不是独立op”。他建议我们可以创建一个模板operator+，这样所有实现的类都会operator+=自动获得operator+：

template<class T>
const T operator+(const T& lhs, const T& rhs)
{ 
    return T(lhs) += rhs; 
}

现在，在 Effective Modern C++ 的第 25 项中，有一个矩阵加法的示例（第 172 页），其中operator+建议使用右值重载，因为如果您知道lhs或者rhs是右值，您可以使用它们来存储结果，防止可能是巨大矩阵的无用副本。所以我添加了重载：

template<class T>
T operator+(T&& lhs, const T& rhs)
{ 
    return std::move(lhs += rhs);
}

template<class T>
T operator+(T const& lhs, T&& rhs)
{ 
    return std::move(rhs += lhs);
}

template<class T>
T operator+(T&& lhs, T&& rhs)
{ 
    return std::move(lhs += rhs);
}

这里的问题是它T&&是一个通用引用，它最终会捕获所有内容，所以我最终从左值移动，这是不受欢迎的行为。

那么如何正确实现operator+模板呢？

使用按值传递的部分解决方案：我还阅读了来自 Effective Modern C++ 的第 41 条：“考虑通过值传递可复制参数 ...”，因此我尝试编写自己的版本，如下所示：

template<class T>
const T operator-(T lhs, T rhs)
{
    return lhs -= rhs;
}

但这错过了当 rhs 是右值时的优化机会，因为在这种情况下，我不会使用 rhs 来存储结果。所以这只是部分解决方案。

4

1 回答 1

3

我认为您的问题是您正在尝试将 C++03 建议（编写泛型operator+）与良好的 C++11 建议（右值重载operator+）结合起来，并且这两条建议不一定兼容。

operator+您要编写的泛型很难正确使用转发引用，但是您可以遵循与原始方法相同的方法并创建一个临时的，lhs如果它是右值，则通过使用std::forward（“通用引用”现在称为转发参考，这应该给你一个线索，处理它们的最佳方法通常std::forward不是std::move）：

template<class T>
    T operator+(T&& lhs, const T& rhs)
    {
        T tmp{ std::forward<T>(lhs) };
        tmp += rhs;
        return tmp;
    }

请注意，这将只接受左侧的右值，因为另一个参数意味着T不会被推断为引用类型，例如， X&而只是对象类型X，因此第一个参数只能匹配右值。

所以我们可以为左侧是左值的情况添加另一个重载：

template<class T>
    T operator+(const T& lhs, const T& rhs)
    {
        T tmp{lhs};
        tmp += rhs;
        return tmp;
    }

这可能不是完全最优的，因为当它是一个右值时，这两个重载都不会重用rhs，但正如我在上面的评论中所说的那样，rhs += lhs除非加法是可交换的，否则它是不正确的。如果您乐于假设它是通勤的，那么您可以改进它以在它是右值时重用rhs（通过添加更多的重载和更多的复杂性）。

operator+就我个人而言，我认为定义的泛型operator+=作为一个练习很有趣，但实际上并不是很实用，尤其是当您考虑到移动语义时。为你的类型编写一个自定义operator+（就像更有效的 C++ 的 p172 上的那个）不是那么多工作，你不必处理转发引用，你会知道该类型的加法是否通勤以及是否安全rhs += lhs与否。

于 2015-07-24T15:54:29.033 回答