超载+ C++ 中泛型类的运算符

Question

我试图在森林类中重载 + 运算符，森林是树木的集合，而 + 运算符应该将两个森林合并为一个。我有以下代码作为我的类定义：

template<typename NODETYPE>
class Forest
{


    public:

        friend Forest& operator+<>(Forest&, Forest&);
        friend ostream& operator<<<>(ostream&, const Forest&);
        friend istream& operator>><>(istream&, Forest&);
        Forest();
        Forest( const Forest& otherForest);
        ~Forest();
        void nodes(int&) const;

    private:
        ForestNode<NODETYPE> *root;

        ForestNode<NODETYPE> *getNewNode( const NODETYPE &);
};

以下是我的operator+ 实现：

template<typename NODETYPE>
Forest& operator+<>(Forest& f1, Forest& f2)
{
    f3 = new Forest();
    f3.root = *f1.*root;
    f3.root.sibling = *f2.*root;
    *f1.root = 0;
    *f2.root = 0;
    return f3;
}

编译时出现以下错误：

 |28|错误：预期的构造函数、析构函数或“&”之前的类型转换代币|

第28行指的是我的operator+实现的签名。

我认为要纠正它，我应该添加到返回类型，给出：

template<typename NODETYPE>
Forest<NODETYPE>& operator+<>(Forest& f1, Forest& f2)
{
    f3 = new Forest();
    f3.root = *f1.*root;
    f3.root.sibling = *f2.*root;
    *f1.root = 0;
    *f2.root = 0;
    return f3;
}

但这给了我以下错误：

 |28|错误：'operator+'声明为非函数|
|28|错误：“&”之前缺少模板参数代币|
|28|错误：“f1”未在此范围内声明|
|28|错误：“&”之前缺少模板参数代币|
|28|错误：“f2”未在此范围内声明|

谁能帮我解决这个问题吗？我将非常非常感激。

Answer 1

编写operator+的关键是不要写operator+。相反，编写一个复制构造函数和operator+=：

template<class NodeType>
struct Forest {
  //...
  Forest(Forest const &other);
  //...
  Forest& operator+=(Forest const &other) {
    // code here
    return *this;
  }
  //...
};

现在我们添加operator+：

template<class NodeType>
struct Forest {
  //...
  friend Forest operator+(Forest a, Forest const &b) {
    a += b;
    return a;
  }
  //...
};

就是这样！复制通常是直接的（有时是不允许的），并且用 += 来思考可能比用 + 更简单（你有两个对象并改变其中一个，而不是从两个对象中创建第三个对象）。 op+ 的这种模式适用于任何类似的类型，甚至适用于类似的运算符，例如 -、* 和 /。

Answer 2

运算符重载可能是好事，也可能是坏事。当它导致代码看起来更简单时，这很好。当它导致编写者重载不正确的语义（但仍是可编译的解决方案）或使用运算符的直观方式导致代码效率极低时，那就不好了。

请注意，后一个语句也适用于 std::string，这可能会产生大量副本，这就是为什么 C++03 标准规定字符串不必在内部存储在连续的缓冲区中（在过去，他们使用写时复制引用，并且可以存储对连接的两个字符串的此类引用，直到需要为止，随后发现它是非线程安全的，因此比简单地复制缓冲区成本更高，所以现在他们复制每个字符串。时间又效率低下）。

（请注意，识别线程和原子问题的 C++11 标准确保底层确实需要连续且以 null 终止，以使读取操作安全）。

operator+ 的正确签名（在所有类型都相同的情况下）如下：

T operator+( const T&, const T& );

作为成员函数，它是：

class T
{
    // make public if necessary
    T operator+( const T& rhs ) const;
};

每当operator += 可用时，您可以自动将operator+ 实现为模板

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

如果您想声明一个重载运算符作为朋友，您的模板，这是正确的方法。我将用运算符<<来显示它

// first some forward declarations, assume ostream already declared with #include <iosfwd> minimum
template< typename T > class Forest;
template< typename T > std::ostream & operator<<( std::ostream & os, const Forest<T> & for );

template< typename T> class Forest
{
     friend std::ostream& operator<< <>( std::ostream&, const Forest<T> & );
     //rest of class Forest
};

template< typename T >
std::ostream & operator<<( std::ostream& os, const Forest<T> & forest )
{
    // implement
    return os;
}

您可以将类似的技术应用于您希望声明为类的友元的任何其他外部函数，即，

1. 将您的类向前声明为模板，
2. 将方法前向声明为模板函数，
3. 使用 <> 使该函数成为友元。在表示参数的左括号之前
4. 在类之后实现该函数。

Answer 3

您必须为所有 Forest 参数提供模板参数。

template<typename NODETYPE>
Forest<NODETYPE> operator+(Forest<NODETYPE>& f1, Forest<NODETYPE>& f2)

另外，请考虑将参数设为 const 引用，以确保您不要操纵它们。

有几个stackoverflow 上有关友元函数模板的问题。 C++ FAQ 上也有一个页面，其中包含解释了一些基础知识。

Answer 4

您可以按如下方式定义 operator+ 模板：

template< class NodeType >
Forest<NodeType> operator+( Forest<NodeType> const& f1, Forest<NodeType> const& f2)
{
    // Implementation.
}

Cheers &呵呵，，