[Problemas] Lista Encadeada e Template

[Thiago Zuquinali]

Oi Pessoal, estou com um problema em uma implementação de lista encadeada usando template. 
Quando crio uma lista e manipulo ela, não dá nenhum problema, mas quando coloco lista como um atributo de uma outra classe, não consigo manipular ela.
Também quando tento atribuir a lista pra outro objeto, o programa para inesperadamente. Seguem os códigos:

 

Lista Encadeada com template: 

#ifndef LISTAENCADEADA#define LISTAENCADEADAtemplate<class T>class ListaEncadeada{private:    //Classe amiga No    class No{        friend class ListaEncadeada<T>;    private:        T   *_item;        No  *_proximo;        No(){            _item = 0;            _proximo = 0;        }        ~No(){            if(_item != 0) delete _item;        }    };    //=====================================    //Atributos    No  *_primeiro;    No  *_ultimo;    No  *_pos;    int _tamanho;    //=====================================public:    //Construtores e Destrutores    ListaEncadeada();    ListaEncadeada(const ListaEncadeada<T> &lista);    ~ListaEncadeada();    //=====================================    //Assinatura dos Metodos    void insere(T &chave);    bool retira(T &chave);    T* primeiro();    T* proximo();    bool vazia();    bool pesquisa(T &chave);    T* pesquisa(int index);    int getTamanho();    //=====================================    //Sobrecarga do operador de atribuicao    ListaEncadeada<T> &operator=(ListaEncadeada byValList);};#endif // LISTAENCADEADA/*    IMPLEMENTACAO*/using namespace std;/*    Descricao: Construtor da classe.    Pre-Condicao: Nenhuma.    Pos-Condicao: Inicializacao dos elementos da lista.*/template<class T>ListaEncadeada<T>::ListaEncadeada(){    this->_primeiro = new No();    this->_pos = this->_primeiro;    this->_ultimo = this->_primeiro;    this->_primeiro->_proximo = 0;    this->_tamanho = 0;}template<class T>ListaEncadeada<T>::ListaEncadeada(const ListaEncadeada<T> &lista){    this->_primeiro = new No();    this->_pos = this->_primeiro;    this->_ultimo = this->_primeiro;    this->_primeiro->_proximo = 0;    this->_tamanho = 0;    No* current = lista._primeiro;    while (current != NULL) {        this->insere(*current->_item);        current = current->_proximo;    }}/*    Descricao: Destrutor da classe Lista.    Pre-Condicao: Lista criada.    Pos-Condicao: Lista destruida.*/template<class T>ListaEncadeada<T>::~ListaEncadeada(){    No *aux = this->_primeiro;    while(aux != 0){        this->_primeiro = this->_primeiro->_proximo;        delete aux;        aux = this->_primeiro;    }}/*    Descricao: Insere um elemento na lista.    Pre-Condicao: Lista criada.    Pos-Condicao: Elemento inserido no comeco da lista.*/template<class T>void ListaEncadeada<T>::insere(T &chave){    this->_ultimo->_proximo = new No();    this->_ultimo = this->_ultimo->_proximo;    this->_ultimo->_item = new T(chave);    this->_ultimo->_proximo = 0;    this->_tamanho++;}/*    Descricao:  Retirar elemento da lista. Retorna verdade se o elemento foi retirado com                exito.    Pre-Condicao: Lista criada.    Pos-Condicao: Caso o elemento exista, ele é removido da lista, caso nao exista, a lista ficara intacta*/template<class T>bool ListaEncadeada<T>::retira(T &chave){    if(this->vazia()){        return  false;    }else{        No *aux = this->_primeiro;        while((aux->_proximo != 0) && (*(aux->_proximo->_item) != chave)){            aux = aux->_proximo;        }        if(aux->_proximo == 0) return false;        No *q = aux->_proximo;        //T *item = q->_item;        aux->_proximo = q->_proximo;        q->_item = 0;        if(aux->_proximo == 0) this->_ultimo = aux;        delete q;        this->_tamanho--;        return true;    }}/*    Descricao: Metodo para retornar o primeiro elemento da lista    Pre-Condicao: Lista criada.    Pos-Condicao: Lista intacta.*/template<class T>T* ListaEncadeada<T>::primeiro(){    this->_pos = this->_primeiro;    return this->proximo();}/*    Descricao: Metodo que retorna o proximo do elemento da posicao atual.    Pre-Condicao: Lista criada.    Pos-Condicao: Elemento "pos" da lista anda uma posicao.*/template<class T>T* ListaEncadeada<T>::proximo(){    this->_pos = this->_pos->_proximo;    if(this->_pos == NULL) return NULL;    else return this->_pos->_item;}/*    Descricao: Retorna verdade caso  lista esteja vazia.    Pre-Condicao: Lista iniciada.    Pos-Condicao: Lista intacta.*/template<class T>bool ListaEncadeada<T>::vazia(){    return (this->_primeiro == this->_ultimo);}/*    Descricao:  Metodo que pesquisa a ocorrencia de um elemento na lista.                Caso o elemento exista, o metodo retorna true, se nao, false.    Pre-Condicao: Lista iniciada.    Pos-Condicao: Lista intacta.*/template<class T>bool ListaEncadeada<T>::pesquisa(T &chave){    if(this->vazia()) return false;    No *aux = this->_primeiro;    while(aux->_proximo != 0){        if(*(aux->_proximo->_item) == chave){            return true;        }        aux = aux->_proximo;    }    return false;}/*    Descricao:  Metodo retorna o elemento do indice de entrada.    Pre-Condicao: Lista inicializada.    Pos-Condicao: Lista intacta.*/template<class T>T* ListaEncadeada<T>::pesquisa(int index){    if(this->vazia()) return 0;    if(index > this->_tamanho) return 0;    No *aux = this->_primeiro;    int i = 0;    while(aux->_proximo != 0){        if(i == index){            return aux->_proximo->_item;        }        aux = aux->_proximo;        i++;    }    return 0;}/*    Descricao: Metodo retorna o tamanho da lista.    Pre-Condicao: Lista inicializada    Pos-Condicao: Lista intacta.*/template <class T>int ListaEncadeada<T>::getTamanho(){    return this->_tamanho;}template<class T>ListaEncadeada<T>& ListaEncadeada<T>::operator=(ListaEncadeada byValList){    std::swap(this->_primeiro, byValList._primeiro);    return *this;} 

 Autor.h e Autor.cpp (Para fins de teste)

#ifndef AUTOR_H#define AUTOR_H#include <string>using namespace std;class Autor{private:    string _nome;public:    Autor(); //Construtor da classe Autor    Autor(Autor &autor); //Construtor da classe Autor    ~Autor();    //Metodo que retorna o nome do Autor    string getNome();    //Metodo que seta o nome do autor    void setNome(string nome);    //Metodo que sobrecarrega o operador de igualdade    //  Quando o nome do autor de entrada é o mesmo que o nome do autor    //  desta classe, então retorna verdade    bool operator==(Autor autor);    //Metodo que sobrecarrega o operador de desigualdade    //  Quando o nome do autor de entrada é diferente que o nome do autor    //  desta classe, então retorna verdade    bool operator!=(Autor autor);};#endif // AUTOR_H

#include "autor.h"//Construtor da classe AutorAutor::Autor(){}//Construtor da classe AutorAutor::Autor(Autor &autor){    this->_nome = autor.getNome();}//Destrutor da classe AutorAutor::~Autor(){}//Retorna o nome do Autorstring Autor::getNome(){    return this->_nome;}//Seta um nome para Autorvoid Autor::setNome(string nome){    this->_nome = nome;}//Sobrecarga do operador de igualdadebool Autor::operator==(Autor autor){    return (this->_nome == autor.getNome());}//SObrecarga do operador de desigualdadebool Autor::operator!=(Autor autor){    return (this->_nome != autor.getNome());}

main que estou testando:

#include <iostream>#include "listaencadeada.h"#include "autor.h"using namespace std;int main(){    ListaEncadeada<Autor> autores;    Autor a1;    a1.setNome("Autor1");    autores.insere(a1);    //l1.addAutor(a1);    a1.setNome("Autor2");    autores.insere(a1);    //l1.addAutor(a1);    a1.setNome("Autor3");    autores.insere(a1);    //l1.addAutor(a1);    a1.setNome("Autor4");    autores.insere(a1);    //l1.addAutor(a1);    cout << "Autores:" << endl;    for(int i = 0; i < autores.getTamanho(); i++){        cout << autores.pesquisa(i)->getNome() << endl;    }    ListaEncadeada<Autor> autoresAux(autores);    //autoresAux = autores;    cout << "Autores Aux:" << endl;    for(int i = 0; i < autoresAux.getTamanho(); i++){        cout << autoresAux.pesquisa(i)->getNome() << endl;    }    return 0;}

valeu pela ajuda pessoal!