模板类里面的嵌套类，如何重载输出运算符？

[Roy_ly]

定义了一个双向链表的类模板，里面嵌套定义一个类作为迭代器，希望通过一系列重载这个嵌套的类的运算符实现跟STL库一样的功能。

首先是个一个双向链表类模板的一部分声明代码，里面定义了一个自己的迭代器嵌套类。

template <typename T>
class MyList
{
public:
class MyIterator
{
private:
Node<T> *pos;

public:
MyIterator() { pos = NULL; }
MyIterator(Node<T> * val) { pos = val; }
MyIterator & operator ++ ()
{
pos = pos->GetNext();
return *this;
}
MyIterator operator ++ (int)
{
MyIterator temp(this->pos);
pos = pos->GetNext();
return temp;
}
bool operator != (MyIterator val)
{
return ((pos->GetNext() != val.pos->GetNext())||(pos->GetPre() != val.pos->GetPre()));
}
void SetPos(Node<T> * val) {pos = val;}
Node<T>* GetPos() { return pos; }
};

private:
Node<T> *pFirst;
Node<T> *pLast;
MyIterator iter;

public:
............
............


然后是希望通过重载 << 运算符，实现直接操作在自定义的迭代器上就能输出迭代器所指数据的功能，如下的代码：

int i = 10;
Node<int> node(i);
MyList<int> list;

list.push_front(node);

cout << node << endl;

MyList<int>::MyIterator myiter = list.Begin();

cout << myiter << endl; // 直接对迭代器输出


以下是我重载运算符的代码的一部分，但是编译不通过，不知道应该怎么写了。。。。

template <typename T>
ostream & operator << (ostream & os, MyList<T>::MyIterator<T> &n)
{
return os << n.iter->GetData() << endl;
}

以上代码编译不通过

请教大家问题在哪里，应该怎么修改？

大概一起涉及了嵌套类，类模板，运算符重载，友元等C++功能，真的搞晕了。。。。。。。

[褚六]

从代码看出 MyIterator就不是个类模板 但你却用了MyIterator<T>这种形式...

[rocktyt]

T在类内部是已知的，对MyIterator来说T并不是个模板类型，所以MyIterator不需要是模板类

[ri_aje]

引用 3 楼 Roy_ly 的回复:

[quote=引用 1 楼 ri_aje 的回复:] 一个小例子。把 operator<< 重载作为友元直接放在类定义内部即可。

#include <iostream>

template <typename T>
struct MyList
{
public:
 struct MyIterator
 {
  int data;
  friend std::ostream& operator << (std::ostream& os, MyIterator const& it)
  {
   return os << it.data << std::endl;
  }
 };
};

int main ()
{
 MyList<int>::MyIterator myiter;
 std::cout << myiter << std::endl;
}

你这个例子不是类模板，你把data定义为普通的int，编译时没有引起实例化，当然没问题。 我要的而是一个模板参数<T>类型的data，编译时实例化就出问题了。[/quote] 不知道你什么意思，主楼的 MyIterator 本来就不是类模板。即便是类模板，我给的那种方法也行。最简单的，你把我的代码复制粘贴一下试试不就行了吗。

[ri_aje]

一个小例子。把 operator<< 重载作为友元直接放在类定义内部即可。

#include <iostream>

template <typename T>
struct MyList
{
public:
 struct MyIterator
 {
  int data;
  friend std::ostream& operator << (std::ostream& os, MyIterator const& it)
  {
   return os << it.data << std::endl;
  }
 };
};

int main ()
{
 MyList<int>::MyIterator myiter;
 std::cout << myiter << std::endl;
}

[飞天御剑流]

MyIterator并不是类模板，是不能MyIterator<T>这样写的。

[Roy_ly]

引用 1 楼 ri_aje 的回复:

一个小例子。把 operator<< 重载作为友元直接放在类定义内部即可。

#include <iostream>

template <typename T>
struct MyList
{
public:
 struct MyIterator
 {
  int data;
  friend std::ostream& operator << (std::ostream& os, MyIterator const& it)
  {
   return os << it.data << std::endl;
  }
 };
};

int main ()
{
 MyList<int>::MyIterator myiter;
 std::cout << myiter << std::endl;
}

你这个例子不是类模板，你把data定义为普通的int，编译时没有引起实例化，当然没问题。 我要的而是一个模板参数<T>类型的data，编译时实例化就出问题了。