超载<<在链表程序中使用模板时，C ++中的运算符 [英] Overloading << operator in C++ when using templates in linked list program
问题描述
我正在尝试实现一个链表. 但是，当我尝试使<<操作员. 这是我的程序:
I'm trying to implement a linked list. But I'm receiving an error when I try overloading the << operator. This is my program:
#include<iostream>
#include<stdlib.h>
using namespace std;
template<class T> class List;
template<class T>
class Node
{
T data;
Node* next;
public:
Node(T val)
{
data = val;
next = NULL;
}
Node(T val, Node* link)
{
data = val;
next = link;
}
friend class List<T>;
friend ostream& operator<<(ostream& out, List<T>* li);
};
template<class T>
class List
{
Node<T>* first;
Node<T>* last;
public:
friend ostream& operator<< (ostream& out, List<T>* li)
{
if(li->first)
out<<"Empty.\n";
else
{
out<<"Displaying: \n";
Node<T>* p = li->first;
while(p)
{
out<<p->data;
p = p->next;
}
}
return out;
}
List()
{
first = last = NULL;
}
List(T val)
{
Node<T>* l = new Node<T>(val);
first = last = l;
}
void insertHead(T val)
{
if(first)
{
Node<T>* p = new Node<T>(val,first);
first = p;
}
else
first = last = new Node<T>(val);
}
void insertTail(T val)
{
if(first)
{
last->next = new Node<T>(val);
last = last->next;
}
else
first = last = new Node<T>(val);
}
void insertAt(T val, int pos)
{
//check if list is empty.
if(first==NULL)
first = new Node<T>(val);
else
if(pos==1)
insertHead(val);
else
{
Node<T>* curr = first;
int i = 1;
// iterate till position is reached.
while( i<pos )
{
curr=curr->next;
i++;
}
//create new node.
Node<T>* p = new Node<T>(val,curr->next);
//link new node to previous node.
curr->next = p;
}
}
void concatenate(List<T>* m)
{
//m is concatenated to end of *this.
if(first)
{
last->next = m->first;
last = m->last;
}
else
{
first = m->first;
last = m->last;
}
m->first = m->last = 0;
}
void delVal(int pos)
{
//if position is first, delete first node.
if( pos == 1 )
{
Node<T>* p = first;
first = first->next;
if(first==0)
last=0;
free(p);
}
//otherwise, iterate till correct position and delete the node.
else
{
int i = 1;
Node<T>* curr = first;
while( i<pos )
{
curr = curr->next;
i++;
}
Node<T>* p = curr->next;
curr->next = p->next;
if(curr->next==0)
last = curr;
free(p);
}
}
void searchVal(T val)
{
Node<T>* curr = first;
int i = 0;
cout<<"Search: ";
while( curr )
{
if( curr->data==val )
{
cout<<val<<" found at position "<<i<<endl;
break;
}
else
{
curr=curr->next;
i++;
}
}
cout<<endl;
}
void recDisplay(Node<T>* curr)
{
if(curr!=0)
{
cout<<curr->data<<endl;
recDisplay(curr->next);
}
}
void Display()
{
cout<<"Displaying: \n";
recDisplay(first);
}
void Reverse()
{
Node<T>* curr = first;
Node<T>* prev = 0;
while( curr )
{
Node<T>* r = prev;
prev = curr;
curr = curr->next;
prev->next = r;
}
first = prev;
}
~List()
{
Node<T>* p = first;
cout<<"Deleting:"<<endl;
while(first!=0)
{
free(first);
first = p->next;
p = first;
}
}
};
int main()
{
List<int>* l = new List<int>();
l->insertHead(5);
l->insertTail(6);
l->insertTail(7);
cout<<l;
}
当我执行此代码时，编译器给我以下错误:
When i execute this code, the compiler gives me the following errors:
警告:朋友声明'std :: ostream&运算符<<(std :: ostream& ;, List *)'声明一个非模板函数[-Wnon-template-friend]
warning: friend declaration 'std::ostream& operator<<(std::ostream&, List*)' declares a non-template function [-Wnon-template-friend]
注意:(如果这不是您想要的，请确保已经声明了功能模板，并在此处在功能名称后添加<>)
note: (if this is not what you intended, make sure the function template has already been declared and add <> after the function name here)
请帮助.
推荐答案
由于它们带有类模板参数，因此您的friends必须是函数模板或函数模板的专业化版本:
Since they take a class template argument, your friends need to be function templates, or specializations of function templates:
// function template friend
template <typename T2>
friend ostream& operator<<(ostream& out, const List<T2>& li);
请注意，通常会重载此运算符以获取引用，而不是如上例中的指针.
Note that one would usually overload this operator to take a reference, not a pointer, as in the example above.
缺点是，这可能不够严格:ostream& operator<<(ostream& out, const List<Widget>& li)是List<int>的朋友.由于这通常不是所需的行为，因此您可以提供模板专门化，这会将友谊限制为与实例化类相同的T:
The drawback is that this is probably not restrictive enough: ostream& operator<<(ostream& out, const List<Widget>& li) would be a friend of List<int>. Since this is not usually the desired behaviour, you can provide a template specialization, which would restrict friendship to the same T as that with which the class is instantiated:
// function template, declared outside of the class:
template <typename T>
ostream& operator<<(ostream& out, const List<T2>& li);
// function template specialization, declared inside the class:
friend ostream& operator<< <>(ostream& out, const List<T>& li);
这篇关于超载<<在链表程序中使用模板时，C ++中的运算符的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
