运算符重载为好友函数

Question

我创建了一个模板类，并想重载一个运算符+（几次）。 我以以下方式进行

template <typename T> class Polynomial;

template <typename T>
const Polynomial<T> operator +(const Polynomial<T>& poly, const T& scalar);

....

template <typename T>
class Polynomial {
    ....

    public:

    ....

    Polynomial operator +(const Polynomial& other) const {
       // impelementation
    }

    friend const Polynomial<T> operator + <> (const Polynomial<T>& poly, const T& scalar);

};

template <typename T>
const Polynomial<T> operator +(const Polynomial<T>& poly, const T& scalar) {
    // implementation
}

但是，出现以下错误（与以“ friend”开头的行相对应）

problem2.cpp:282:45: error: declaration of ‘operator+’ as non-function
problem2.cpp:282:45: error: expected ‘;’ at end of member declaration
problem2.cpp:282:47: error: expected unqualified-id before ‘<’ token

按照Raxvan的建议，我更改了代码

模板类多项式；

template <typename T>
const Polynomial<T> operator +(const Polynomial<T>& poly, const T& scalar);

template <typename T>
ostream& operator <<(ostream& out, const Polynomial<T>& other);

....

template <typename T>
class Polynomial {
    ....

    public:

    ....

    friend ostream& operator << <> (ostream& out, const Polynomial<T>& other);

    Polynomial operator +(const Polynomial& other) const {
       // impelementation
    }

    template <typename NOT_T>
    friend const Polynomial<NOT_T> operator +(const Polynomial<NOT_T>& poly, const NOT_T& scalar);

};

template <typename T>
ostream& operator <<(ostream& out, const Polynomial<T>& other) {
    // implementation
}

template <typename T>
const Polynomial<T> operator +(const Polynomial<T>& poly, const T& scalar) {
    // implementation
}

在这段代码中，运算符<<不会像运算符+那样出现问题。 谁能解释这个差异？

Answer 1

问题很细微。 您的语法非常接近正确。 我认为您的朋友声明应该是：

friend Polynominal<T> const operator+<T>( ... );

但是VC ++和g ++都接受：

friend Polynominal<> const operator+<T>( ... );

当他们看到声明时：

template <typename T>
const Polynomial<T> operator+(const Polynomial<T>& poly, const T& scalar);

（我无法在标准中找到任何可以证明这一点的理由，但是由于VC ++和g ++都可以做到这一点，所以我想这是我错过的东西。）

问题就在这里。 类内定义隐藏了operator+命名空间范围内的声明。 编译器抱怨是因为它发现的operator+ （类定义中）本身不是模板（尽管它是类模板的成员）。

如果您没有operator<<的问题，那是因为您没有同名的成员函数。

有几种解决此问题的方法。 最简单的方法可能是结交所有operator+朋友。 是否：最常见的方法是根据operator+=来实现operator+ （在所有情况下都应该是成员）。 在这种情况下， operator+不必是朋友。 或者您根本不将operator+作为模板，而是在类模板中将其定义为：

template <typename T>
class Polynomial
{
    friend Polynomial operator+( Polynomial const& lhs, Polynomial const& rhs )
    {
        //  ...
    }
    friend Polynomial operator+( Polynomial const& lhs, T const& rhs )
    {
        //  ...
    }
    friend Polynomial operator+( T const& lhs, Polynomial const& rhs )
    {
        //  ...
    }
}

（请注意，所定义的函数不是模板，而是单独的重载非模板函数，每个实例化Polynomial 。但是结果最终是相同的。）

在这种情况下，您可能希望有一个由operator+函数调用的成员函数，该函数可以完成实际的工作； 您不需要像这样直接内联太多代码。

Answer 2

将函数标记为好友时，必须具有相同的定义，这包括上面使用的具有另一种类型的模板，而不是T

template <typename T> class Polynomial;

template <typename T>
const Polynomial<T> operator +(const Polynomial<T>& poly, const T& scalar);

template <typename T>
class Polynomial {
public:

    template < class NOT_T> //must respect the deffinition from above
    friend const Polynomial<NOT_T> operator + (const Polynomial<NOT_T>& poly, const NOT_T& scalar);

};

template <typename T>
const Polynomial<T> operator +(const Polynomial<T>& poly, const T& scalar)
{
    //...
}

编辑：

为了简化说明，我将函数更改为foo和bar以说明声明的区别：

template <typename T> class Polynomial;

template <typename T>
void bar(const Polynomial<T>& );

void foo(const Polynomial<float> & );//foo for speciffic float

template <typename T>
class Polynomial {
public:
    template <typename> //this is also valid declaration; 
    friend void bar(const Polynomial<T> & );
    //it just has to have template because it's a template functions declaration

    //not a valid declaration:
    //friend void bar <> (const Polynomial<T> & );

    //this declaration has no template;
    //it refers to a foo function specific to Polynomial<T> type
    //so if you use Polynomial<float> there must be a foo for floats
    friend void foo(const Polynomial<T> &);
};

template <class T>
void bar(const Polynomial<T>&)
{
}

void foo(const Polynomial<float> &)
{
}

void main()
{
    Polynomial<float>   pf;
    Polynomial<int>     pi;

    foo(pi);//error since there is not **foo** declared for int 
    foo(pf);//ok; we have **foo** for  Polynomial<float>

    bar(pf);
    bar(pi);//both ok since bar is templated function;
}

Raxvan。

Answer 3

您的operator+是一个功能模板，要使其成为朋友，您需要完整地声明它，包括模板参数，但是使用不同的模板参数，例如：

#include <iostream>

template <typename T> class Polynomial;

template <typename T>
const Polynomial<T> operator +(const Polynomial<T>& poly, const T& scalar);

template <typename T>
class Polynomial {
    public:

    Polynomial operator +(const Polynomial& other) const {
      std::cout << "inline +" << std::endl;
    }

    // Here introduce a different type to indicate that this is a template...
    template <typename U>
    friend const Polynomial<U> operator + (const Polynomial<U>& poly, const U& scalar);

};

template <typename T>
const Polynomial<T> operator +(const Polynomial<T>& poly, const T& scalar) {
    std::cout << "friend +" << std::endl;
}

int main(void)
{
  Polynomial<int> f;

  f = f + 1;

  f = f + 1.; // this fails

  f = f + Polynomial<int>();
}