预期的构造函数，析构函数或类型转换

Question

我正在写与迭代我自己的模板列表类，并且有这个错误（（（ 编译：从MinGW的GCC（我使用Eclipse IDE） 我的代码： CPP：

#include <iostream> 
#include "tlist.h" 
using namespace std; 
int main(){ 
    return 0; 
} 

头

template<typename T> 
class element{ 
private: 
    element<T>* pre; 
    element<T>* next; 
    T data; 
public: 
    element(){}; 
    ~element(){}; 
    element(T d){ 
     pre=NULL; 
     next=NULL; 
     data=d; 
    } 
    void SetPre(element<T>* a){ 
     pre=a; 
    }; 
    void SetNext(element<T>* a){ 
     next=a; 
    }; 
    void SetData(T d){ 
     data=d; 
    } 
    element<T>* GetPre(){ 
     return pre; 
    } 
    element<T>* GetNext(){ 
     return next; 
    } 
    T GetData(){ 
     return data; 
    } 
}; 
template<typename T> 
class Tlist{ 
private: 
    element<T>* first; 
    element<T>* last; 
    int size; 
public: 
     int GetSize(){ 
     return size; 
    } 
     Tlist(){ 
     first=NULL; 
     last=NULL; 
     size=0; 
    } 
     ~Tlist(){}; 
     Tlist(T d){ 
     element<T>* tmp; 
     tmp->SetPre(NULL); 
     tmp->SetNext(NULL); 
     tmp->SetData(d); 
     this->size=1; 
     this->first=tmp; 
     this->last=tmp; 
       } 
    class Iterator{ 
    private: 
     element<T>* pointing; 
    public: 
     Iterator(){ 
      pointing=NULL; 
     }; 
     ~Iterator(){}; 
     Tlist<T>::Iterator& operator++(int i); 
     element<T>* operator*(); 
     Iterator(element<T>* b){ 
      pointing=b; 
     } 
    }; 
    bool empty(); 
    void clear(); 
    void swap(Tlist<T>& lst); 
    Tlist<T>::Iterator begin(); 
    Tlist<T>::Iterator end(); 
    T front(); 
    T back(); 
    void push_back(T t); 
    void push_front(T t); 
    void pop_front(); 
    void pop_back(); 
    Tlist<T>::Iterator insert(Tlist<T>::Iterator pos,T data); 
    Tlist<T>::Iterator erase(Tlist<T>::Iterator pos); 
    void splice(Tlist<T>::Iterator pos,Tlist<T>* in); 
    Tlist<T> operator=(Tlist<T> const &other){ 
    this->size=other.size; 
    this->first=other.first; 
    this->last=other.last; 
    return *this; 
}; 
}; 
template<typename T> 
Tlist<T>::Iterator& Tlist<T>::Iterator::operator++(int i){ 
    element<T>* temp=*this; 
    if(temp->GetNext()!=NULL) this->pointing=temp->GetNext(); 
    return *this; 
} 
template<typename T> 
element<T>* Tlist<T>::Iterator::operator*(){ 
    return pointing; 
} 
template<typename T> 
bool Tlist<T>::empty(){ 
      if(this->size==0) return true; 
      else return false; 
}; 
template<typename T> 
void Tlist<T>::clear(){ 
      element<T>* son; 
      element<T>* temp; 
      son=this->first; 
      while(son!=NULL){ 
       temp=son->next; 
       delete son; 
       son=temp; 
      } 
      this->size=0; 
}; 
template<typename T> 
void Tlist<T>::swap(Tlist<T>& lst){ 
      int temp=this->size; 
      this->size=lst->size; 
      lst->size=temp; 
      Tlist<T>* tmp; 
      *tmp=*this; 
      *this=lst; 
      lst=*tmp; 
} 
template<typename T> 
Tlist<T>::Iterator Tlist<T>::begin(){ 
       Tlist<T>::Iterator res(this->first); 
       return res; 
}; 
template<typename T> 
Tlist<T>::Iterator Tlist<T>::end(){ 
       Tlist<T>::Iterator res(this->last); 
       return res; 
} 
template<typename T> 
T Tlist<T>::front(){ 
return this->first->GetData(); 
} 
template<typename T> 
T Tlist<T>::back(){ 
    return this->last->GetData(); 
}; 
template<typename T> 
void Tlist<T>::push_front(T d){ 
    element<T>* temp(d); 
    this->size++; 
    this->first->SetPre(temp); 
    temp->SetNext(this->first); 
    this->first=temp; 
} 
template<typename T> 
void Tlist<T>::push_back(T d){ 
    element<T>* temp(d); 
    this->last->SetNext(temp); 
    this->size++; 
    temp->SetPre(this->last); 
    this->last=temp; 
} 
template<typename T> 
void Tlist<T>::pop_front(){ 
    element<T>* temp=this->first->GetNext; 
    delete this->first; 
    this->first=temp; 
    this->size--; 
} 
template<typename T> 
void Tlist<T>::pop_back(){ 
    element<T>* temp=this->last; 
    delete this->last; 
    this->last=temp; 
    this->size--; 
} 
template<typename T> 
Tlist<T>::Iterator Tlist<T>::insert(Tlist<T>::Iterator pos,T d){ 
    element<T>* temp(d); 
    element<T>* p=*pos; 
    element<T>* n=p->GetNext(); 
    p->SetNext(temp); 
    temp->SetPre(p); 
    if(n!=NULL){ 
     n->SetPre(temp); 
     temp->SetNext(n); 
    } 
    this->size++; 
    return pos++; 
} 
template<typename T> 
Tlist<T>::Iterator Tlist<T>::erase(Tlist<T>::Iterator pos){ 
    if(pos==this->end()){ 
        this->pop_back(); 
        return this->end(); 
       } 
    if(pos==this->begin()){ 
     this->pop_front(); 
     return this->begin(); 
    } 
    else{ 
     element<T>* del=*pos; 
     element<T>* p=del->GetPre(); 
     element<T>* n=del->GetNext(); 
     pos++; 
     p->SetNext(n); 
     n->SetPre(p); 
     delete del; 
     this->size--; 
     return pos; 
    } 
}; 
template<typename T> 
void Tlist<T>::splice(Tlist<T>::Iterator pos,Tlist<T>* a){ 
    this->size+=a->GetSize(); 
    element<T>* p=*pos; 
    element<T>* n=p->GetNext(); 
    p->SetNext(a->first); 
    a->first->SetPre(p); 
    n->SetPre(a->last); 
    a->last->SetNext(n); 
    a->size=0; 
    a->first=NULL; 
    a->last=NULL; 
} 

和错误是：

..\tlist.h:99: error: expected constructor, destructor, or type conversion before '&' token 
..\tlist.h:136: error: expected constructor, destructor, or type conversion before 'Tlist' 
..\tlist.h:141: error: expected constructor, destructor, or type conversion before 'Tlist' 
..\tlist.h:184: error: expected constructor, destructor, or type conversion before 'Tlist' 
..\tlist.h:198: error: expected constructor, destructor, or type conversion before 'Tlist' 

帮我，如果可以的话，请

Answer 1

当你说

Tlist<T>::anything 

编译器首先认为你可能是指称为anything类Tlist<T>的一些静态变量。为了告诉它你表示型，你应该预先考虑结构与typename：

template<typename T> 
typename Tlist<T>::Iterator& TList<T>::Iterator::operator++(int){ 
... 

（编辑：只是碰到了一个article上typename）