Question

I’m writing my own template list class with iterator, and have this error(((
compiler:GCC from MinGW( i use Eclipse IDE )
my code:
cpp:

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

header

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;
}

and the errors are:

..\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'

help me, if you can, please

Answer 1

When you say

Tlist<T>::anything

the compiler first thinks you may mean some static variable of the class Tlist<T> called anything. In order to tell it you indicate a type, you should prepend the construct with typename:

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

(edit: just bumped into an article on typename)