有关“=”重载的有关问题

 
 template <class T>  
 class SeqList  
 {  
 private:  
 	T *data;  
 	int size;  
 	int MaxSize;  
 public:  
 	SeqList(int sz = 100);  
 	~SeqList() { delete []data; }  
 	int Length() const { return size; }     
 	bool IsEmpty() const { return size == 0; }  
 	void Insert(const T &x, int k);  
 	void Delete(int k);  
 	T GetData(int k) const;  
 	int Find(const T &x) const; 
 	int countSize(){return size;} 
 	void Output(ostream &out) const;  
 };  

 template <class T>  
 SeqList <T>::SeqList(int sz)  
 { MaxSize=sz;  
 data=new T[MaxSize];  
 size=0;  
 }  

 template <class T>  
 void SeqList <T>::Insert(const T &x, int k)  
 {  
 	if( k <1 || k>size+1 )  
 	{ cerr < <"越界出错"; exit(1); }      
 	if(size==MaxSize)  
 	{ cerr < <"顺序表已满"; exit(1); }     
 	for(int i=size-1; i>=k-1; i--) data[i+1]=data[i];  
 	data[k-1]=x;  
 	size++;  
 }  

 template <class T>  
 void SeqList <T>::Delete(int k)  
 {  
 	if(size==0)  
 	{ cerr < <"顺序表空"; exit(1); }       
 	if( k <1 || k>size )  
 	{ cerr < <"越界出错"; exit(1); }        
 	for(int i=k; i <size; i++) data[i-1]=data[i];  
 	size--;  
 }  

 template <class T>  
 T SeqList <T>::GetData(int k) const  
 {  
 	if( k <1 || k>size )  
 	{ cerr < <"越界出错"; exit(1); }     
 	return data[k-1];  
 }  

 template <class T>  
 int SeqList <T>::Find(const T &x) const  
 {  
 	int i=0;  
 	while(i <size && data[i]!=x) i++;  
 	if(i <size) return i+1;  
 	else return 0;  
 }  

 /*或  
 template <class>  
 int SeqList <T>::Find(const T &x) const  
 {  
     for(int i=0; i <size; i++)  
         if(data[i]==x) return i+1;  
     return 0;     
 } //*/ 

 template <class T>  
 void SeqList <T>::Output(ostream &out) const  
 {  
 	for(int i=0; i <size-1; i++)  
 		out  < < data[i]  < < ", ";  
 	cout  < < data[size-1]; 
 }  

 template <class T>  
 ostream& operator < <(ostream &out, const SeqList <T> &x)  
 {  
 	x.Output(out);  
 	return out;  
 }  

#include <fstream>
#include "SeqList.h"

using namespace std;

template <typename T>
class Set
{
public:
    Set( int sz = 100 );
    ~Set(){ delete []seqSet; }
    void IsEmpty();
    void addMember(const T x);
    void delMember(const T x);
    void display();
    void Contains(const T x);
    void count();
    T getElement(int k) const;
    Set<T>& operator=(const Set<T>& R);

private:
    SeqList<T> *seqSet;
};

template <typename T>
Set<T>::Set(int sz )
{
    seqSet = new SeqList<T>( sz );
}

template <typename T>
void Set<T>::IsEmpty()
{
    if(seqSet->IsEmpty())
    {
        cout << "空！" << endl;
    }
    else
    {
        cout << "不为空！" << endl;
    }
}

template <typename T>
void Set<T>::addMember(const T x)
{
    seqSet->Insert(x, 1);
}

template <typename T>
void Set<T>::delMember(const T x)
{
    seqSet->Delete(seqSet->Find(x));
}

template <typename T>
void Set<T>::display()
{
    cout << "{ ";
    seqSet->Output(cout);
    cout << " }";
}

template <typename T>
void Set<T>::Contains(const T x)
{
    if(seqSet->Find( x ))
    {
        cout << "包含此元素！" << endl;
    }
    else
    {
        cout << "不包含此元素！" << endl;
    }
}

template <typename T>
void Set<T>::count()
{
    cout << seqSet->countSize();
}

template <typename T>
T Set<T>::getElement(int k) const
{
    return seqSet->GetData(k);
}

template <typename T>
Set<T>& Set<T>::operator =(const Set<T> &R)
{
    delete []seqSet;
    seqSet = new SeqList<T>(R.seqSet->countSize());
    for ( int i = R.seqSet->countSize(); i < 1; i-- )
    {
        seqSet->Insert(R.getElement(i),i);
    }
     return this;
}