我正在尝试为返回流的二叉树实现一个方法。我想使用方法中返回的流在屏幕上显示树或将树保存在文件中:

这两个方法在二叉树的类中:

声明:

void streamIND(ostream&,const BinaryTree<T>*);
friend ostream& operator<<(ostream&,const BinaryTree<T>&);

template <class T>
ostream& operator<<(ostream& os,const BinaryTree<T>& tree) {
    streamIND(os,tree.root);
    return os;
}

template <class T>
void streamIND(ostream& os,Node<T> *nb) {
    if (!nb) return;
    if (nb->getLeft()) streamIND(nb->getLeft());
    os << nb->getValue() << " ";
    if (nb->getRight()) streamIND(nb->getRight());
}

此方法在 UsingTree 类中:

void UsingTree::saveToFile(char* file = "table") {
    ofstream f;
    f.open(file,ios::out);
    f << tree;
    f.close();
}

所以我重载了 BinaryTree 类的运算符“<”以使用:cout>< tree="" 和="" ofstream="" f="">< tree，但我收到下一条错误消息:undefined="" reference="" to=""><(std::basic_ostream>&, 二叉树&)'

附言树存储 Word 对象(带有 int 的字符串)。

我希望你能理解我糟糕的英语。谢谢! 我想知道一本适合初学者的关于 STL 的好书，它解释了所有必要的内容，因为我把所有的时间都浪费在了这样的错误上。

编辑:声明 saveToFile() 中的树:BinaryTree< word=""> 树。

最佳答案

问题是编译器没有尝试使用模板化的 operator<<你提供的，而是一个非模板版本。

当您在类中声明一个友元时，您是在封闭范围内注入(inject)该函数的声明。以下代码具有声明(而不是定义)一个采用 non_template_test 的自由函数的效果。通过常量引用论证:

class non_template_test
{
   friend void f( non_template_test const & );
};
// declares here:
// void f( non_template_test const & ); 

模板类也会发生同样的情况，即使在这种情况下它不太直观。当您在模板类主体中声明(而不是定义)一个友元函数时，您是在声明一个具有该确切参数的自由函数。请注意，您声明的是函数，而不是模板函数:

template<typename T>
class template_test
{
    friend void f( template_test<T> const & t );
};
// for each instantiating type T (int, double...) declares:
// void f( template_test<int> const & );
// void f( template_test<double> const & );

int main() {
    template_test<int> t1;
    template_test<double> t2;
}

那些自由函数被声明但没有被定义。这里棘手的部分是那些自由函数不是模板，而是声明的常规自由函数。当您将模板函数添加到组合中时，您会得到:

template<typename T> class template_test {
   friend void f( template_test<T> const & );
};
// when instantiated with int, implicitly declares:
// void f( template_test<int> const & );

template <typename T>
void f( template_test<T> const & x ) {} // 1

int main() {
   template_test<int> t1;
   f( t1 );
}

当编译器命中主函数时，它会实例化模板 template_test与类型 int并且声明了自由函数 void f( template_test<int> const & )那不是模板化的。当它发现调用 f( t1 )有两个f匹配的符号:非模板f( template_test<int> const & )在 template_test 时声明(但未定义)被实例化，模板化版本在 1 声明和定义.非模板版本优先，编译器匹配它。

当链接器尝试解析 f 的非模板版本时它找不到符号，因此失败。

我们能做什么？有两种不同的解决方案。在第一种情况下，我们让编译器为每个实例化类型提供非模板函数。在第二种情况下，我们将模板化版本声明为友元。它们略有不同，但在大多数情况下是等同的。

让编译器为我们生成非模板函数:

template <typename T>
class test 
{
   friend void f( test<T> const & ) {}
};
// implicitly

这具有根据需要创建尽可能多的非模板化自由函数的效果。当编译器在模板中找到友元声明时 test它不仅找到声明，还找到实现并将两者添加到封闭范围。

使模板化版本成为 friend

要使模板成为友元，我们必须已经声明它并告诉编译器我们想要的友元实际上是一个模板，而不是一个非模板化的自由函数:

template <typename T> class test; // forward declare the template class
template <typename T> void f( test<T> const& ); // forward declare the template
template <typename T>
class test {
   friend void f<>( test<T> const& ); // declare f<T>( test<T> const &) a friend
};
template <typename T> 
void f( test<T> const & ) {}

在这种情况下，在声明 f 之前作为模板，我们必须转发声明模板。申报f模板我们必须先转发声明test模板。友元声明被修改为包含尖括号，用于标识我们要成为友元的元素实际上是模板而不是自由函数。

回到问题

回到您的特定示例，最简单的解决方案是让编译器通过内联友元函数的声明为您生成函数:

template <typename T>
class BinaryTree {
   friend std::ostream& operator<<( std::ostream& o, BinaryTree const & t ) {
      t.dump(o);
      return o;
   }
   void dump( std::ostream& o ) const;
};

使用该代码，您将强制编译器生成一个非模板化的 operator<<对于每个实例化类型，生成的函数委托(delegate) dump模板的方法。

关于c++ - 为模板类重载运算符<<，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/1810753/