List类c++实现(加强版)

List(T);
public:
void clear();
~List() {this->clear();}
public:
class Iterator
{
friend class List<T>;
protected:
node *Iter;
Iterator(node *iter)
if(i>=size)
{
cout<<"Overflow error!!"<<endl;
exit(0);
}
{
T data;
node *next;
node *last;
};
private:
node *head;
node *rear;
int size;
public: //构造函数
List();
List(const List<T>&);
List(T,int );
{
Iter =Iter->last;
return *this;
}
Iterator &operator = (Iterator& it)
{
Iter =it.Iter;
return *this;
head=p1;head->last=NULL;
rear=p1;rear->next=NULL; size=1;
return *this;
}
node *p0=list.head;
node *p2=(node*)malloc(sizeof(node));
#include<iostream>
#include<stdlib.h>
#include<string>
using namespace std;
template <class T>
class List
{
friend class Iterator;
protected:
struct node
return Iter!=iter.Iter;
}
T operator *()
{
return Iter->data;
}
Iterator &operator[] (int n)
{
for(int i=0;i<n;i++)
rear->next=NULL;
node *p1=p4->next,*p3=p4;
while(p1->next!=NULL)
{
p1->last=p3;
p1=p1->next;
p3=p3->next;
}
T &back() {return rear->data;}
bool empty(){ return size==0;}
void link(List<T> &list0){ *this+=list0;}
void reset(Iterator &it,T val){ (it.Iter)->data=val;}
}
bool operator ==(const Iterator &iter)
{
return Iter==iter.Iter;
}
bool operator !=(const Iterator &iter)
{
this->rear=NULL;
return *this;
}
if(list.size==1)
{
node *p1=(node*)malloc(sizeof(node));
p1->data=list.head->data;
head->last=NULL;free(tp);
return Iterator(head);
}
if(it.Iter==rear)
{
node *tp=rear;
rear=rear->last;
rear->next=NULL;free(tp);
p1->last=p3;
size+=list.size;
}
T &operator[] (int i)
{
if(i>=size)
{
cout<<"Overflow error!!"<<endl;
exit(0);
}
{
node *p0=list.head;
node *p2=(node*)malloc(sizeof(node));
p2->data=p0->data;
node *p4=rear;
rear->next=p2; rear=p2;
while(p0->next!=NULL)
}
return Iterator(NULL);
}
Iterator begin(){ return Iterator(head);}
Iterator end(){ return Iterator(NULL);}
T &front(){return head->data;}
{
p0=p0->next;
node *p2=(node*)malloc(sizeof(node));
p2->data=p0->data;
rear->next=p2; rear=p2;
}
return Iterator(head);
}
(it.Iter->last)->next=it.Iter->next;
(it.Iter->next)->last=it.Iter->last;
node *ans=it.Iter->next; free(it.Iter);
}
};
public: //功能函数
List<T> sublist(Iterator&, Iterator&);
List<T> sublist( Iterator&,int);
List<T> sublist( Iterator&);
void push_back(const T);
p2->data=p0->data;
head=p2;rear=p2;
head->last=NULL;
while(p0->next!=NULL)
{
p0=p0->next;
node *p2=(node*)malloc(sizeof(node));
return Iterator(ans);
}
Iterator find(T val)
{
node *tp=head;
for(;tp!=NULL;tp=tp->next)
{
if((tp->data)==val) return Iterator(tp);
{
if(Iter==NULL)
{
cout<<"Overflow error!!"<<endl;
exit(0);
}
Iter=Iter->next;
}
return *this;
(it2.Iter)->data=tp;
}
Iterator erase(Iterator &it)
{
if(size==0)
{
cout<<"List is empty!!"<<endl;
exit(0);
}
size--;
if(size==0)
bool down_order(); //降序
int get_size(){ return size;}
friend void swap(Iterator &it1,Iterator &it2)
{
T tp=(it1.Iter)->data;
(it1.Iter)->data=(it2.Iter)->data;
p1->last=p3;
p1=p1->next;
p3=p3->next;
}
p1->last=p3;
size=list.size;
return *this;
}
void operator += (const List<T>&list)
p2->data=p0->data;
rear->next=p2; rear=p2;
}
rear->next=NULL;
node *p1=head->next,*p3=head;
while(p1->next!=NULL)
{
{
Iter=iter;
}
public:
Iterator(){}