有关 c++ 中模板上的重载运算符的一些编译器错误；

Question

我有一些代码有一些错误，我根本不明白如何修复。我问了我的教授和助教，并查阅了互联网，除了更准确地理解错误的含义之外，没有运气。据我所知，编译器要么将我的重载运算符与内置运算符混淆，要么根本不将其识别为重载运算符。

我收到以下错误和警告：

||=== project 4, Debug ===|
\project 4\forest.h|13|warning: friend declaration 'Forest<NODETYPE>& operator+(Forest<NODETYPE>&, Forest<NODETYPE>&)' declares a non-template function|

\project 4\forest.h|13|note: (if this is not what you intended, make sure the function template has already been declared and add <> after the function name here) |

\project 4\forest.h|14|warning: friend declaration 'std::ostream& operator<<(std::ostream&, const Forest<NODETYPE>&)' declares a non-template function|

\project 4\forest.h|15|warning: friend declaration 'std::istream& operator>>(std::istream&, Forest<NODETYPE>&)' declares a non-template function|

\project 4\main.cpp||In function 'int main()':|
\project 4\main.cpp|21|error: ambiguous overload for 'operator>>' in 'file >> intForest'|

c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.4.1\include\c++\istream|119|note: candidates are: std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(std::basic_istream<_CharT, _Traits>& (*)(std::basic_istream<_CharT, _Traits>&)) [with _CharT = char, _Traits = std::char_traits<char>] <near match>|

c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.4.1\include\c++\istream|123|note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(std::basic_ios<_CharT, _Traits>& (*)(std::basic_ios<_CharT, _Traits>&)) [with _CharT = char, _Traits = std::char_traits<char>] <near match>|

c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.4.1\include\c++\istream|130|note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(std::ios_base& (*)(std::ios_base&)) [with _CharT = char, _Traits = std::char_traits<char>] <near match>|
||=== Build finished: 1 errors, 3 warnings ===|

当我尝试编译代码时。相关代码段如下：（

在forest.h中）

template< typename NODETYPE > class Forest
{

    public:
        friend Forest<NODETYPE>& operator+(Forest<NODETYPE>&, Forest<NODETYPE>&);
        friend ostream& operator<<(ostream&, const Forest<NODETYPE>&);
        friend istream& operator>>(istream&, Forest<NODETYPE>&);

        Forest();
        Forest( const Forest& otherForest);
        ~Forest();
        void nodes(int&) const;

    private:
        ForestNode<NODETYPE> *root;

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

（在forest.cpp中）

template<typename NODETYPE> istream& operator>>(istream& file, const Forest<NODETYPE>& f1)
{
    istream file2 = file;
    int nodeCount = 0;
    string blah = ' ';

    while(getline(file2,blah))
    {
        nodeCount++;
    }

    ForestNode<NODETYPE> *forestNodeArray[nodeCount];//holds pointers to last node of depth i

    getline(file,*f1.root.tag);
    forestNodeArray[0] = &(*f1.root);
    inputHelper(file, 0, *f1.root, forestNodeArray, nodeCount);

    return file;
}

（最后在main.cpp中）

int main()
{

    Forest < char > intForest();
    filebuf fb;
    fb.open ("forest1.txt",ios::in);
    istream file(&fb);


    cout << typeid(intForest).name() << endl;
    cout << typeid(file).name() << endl;

    file >> intForest;

    fb.close();


}

任何帮助将不胜感激。

编辑：感谢 alex 和 alf，我明白为什么它们不被视为模板函数。回想起来很明显，我只是决定了这些签名。无论如何，我仍然收到有关不明确运算符的错误。为什么编译器无法识别我的运算符并使用它，而不是尝试在不可能有​​一个参数为 Forest 的运算符的 3 个内置版本之间做出决定？

Answer 1

第二个错误位于这一行：

Forest < char > intForest();

一开始这可能会令人惊讶，但该行并未声明 Forest 类型的变量，而是声明一个不带参数并返回 的函数>森林。
只需从声明中删除括号：

Forest < char > intForest;

在第一个警告上，这已经被解释过（声明为朋友的函数不是模板，这意味着您必须手动为用于实例化 Forest< 的每种类型实现它;> with （可能您不希望这样）。另请注意，声明模板化 operator+ ，然后将模板设为友元，如 @Alf P. Steinbach 答案中所示： Forest 将是 Forest 的友元，这可能不是您所需要的 @Alex 提案，只会进行特定的实例化。模板是一个友元，这可能更接近您想要的，但是您需要在模板类之前声明模板化运算符，为此您需要向前声明模板类...

友元自由函数的常见模式模板正在就地定义函数：

template <typename T>
class Forest {
   // ...
   friend Forest& operator+( Forest const & lhs, Forest const & rhs ) [1]
   {
       // implementation here
   }
}
// [1] Note that the arguments are const references (read only), and also note that
//     you do not need to provide the type argument inside the template declaration

这允许您将其定义为非模板化函数，同时让编译器为您实例化该函数。此外，在处理模板时，在类定义中内嵌成员方法通常会更简单。它使生活变得更简单，毕竟在大多数情况下，您确实需要在（同一）头文件中提供实现。

然而，在定义二元运算符时，更好的方法是将 operator+= 定义为成员方法，然后您可以轻松地将 operator+ 定义为非友元自由函数。模式是：

struct test {
   test& operator+=( test const & );
};
test operator+( test lhs, test const & rhs ) { // [2]
   lhs += rhs;
   return lhs;
}
// [2] Note that the first argument is by value, and the second by const reference
//     This means that the compiler will copy the first argument for you, and you
//     are free to modify it with the += operator and return the copy.

现在，最棘手的部分是混合前两个建议。为了能够在模板定义中定义作为自由函数的 operator+，一个常见的技巧是使其成为友元，即使由于访问原因不需要这样做：

template <typename T>
class Forest {
   Forest& operator+=( Forest const & ) {
      // implemenation
   }
   friend Forest operator+( Forest lhs, Forest const & rhs ) { // [3]
      return lhs+=rhs;
   }
};
// [3] friendship only to allow us to define the free function inside the template
//     declaration.

Answer 2

（第一个）警告告诉您 befriended 函数不是模板。

但事实并非如此。

考虑一下你将如何实施它。这需要为每种可能的 NODE_TYPE 编写一个这样的函数。

有几种方法可以解决这个问题。

一种方法是与函数模板成为朋友，如下所示：

template< class Type >
struct S
{
    template< class U > friend void foo( S<U> );
};

template< class Type >
void foo( S< Type > x ) {}

int main()
{}

Cheers &呵呵，，

Answer 3

学习C++，我也遇到了同样的问题。但是我已经用另一种方式解决了！

template <class NODETYPE> class Forest;
template <class NODETYPE> Forest<NODETYPE>& operator+ (Forest<NODETYPE>&, Forest<NODETYPE>&);
template <class NODETYPE> ostream& operator<<(ostream&, const Forest<NODETYPE>&);
template <class NODETYPE>  istream& operator>> (istream&, Forest<NODETYPE>&);
template<class NODETYPE>
template< typename NODETYPE >
class Forest
{

    public:
        friend Forest<NODETYPE>& operator+ <>(Forest<NODETYPE>&, Forest<NODETYPE>&);
        friend ostream& operator<< <>(ostream&, const Forest<NODETYPE>&);
        friend istream& operator>> <>(istream&, Forest<NODETYPE>&);

        Forest();
        Forest( const Forest& otherForest);
        ~Forest();
        void nodes(int&) const;

    private:
        ForestNode<NODETYPE> *root;

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