我的模板不工作(c++)-我做错了什么

这是我定义模板和另外3个类的地方

#ifndef PLANILHAH
#define PLANILHAH
#include <iostream>
#include "planilha_func.h"
template <class TIPO> class planilha {
    friend class celula;
    friend class listaT;
    friend class elo;
    protected:
    celula * primeiro;
    unsigned int count;
    public:
    planilha();
    planilha(const planilha<TIPO>& origem);
    ~planilha(void)
    TIPO obtem_valor(const unsigned int num_cel);
    //many more methods
};

我不知道我是否应该使这个嵌套类在'planilha'或不，如果我使它嵌套，我如何实现它?它需要接收类型'TIPO'

template <class TIPO> class celula{
    friend class listaT;
    friend class elo;
    protected:
    unsigned int idCelula;
    TIPO constante;
    TIPO total;
    listaT termos;
     //etc
    void insere(int novoCons);
    void apaga();
    void setIdCelula(unsigned int idCelula);
    void setTotal(TIPO total);
    TIPO getTotal() const;
    TIPO getConstante() const;
    void setConstante(TIPO constante);
};

我不知道朋友类是不是最好的选择，这些都是在cellula类中使用的

class listaT {
    friend class elo;
    protected:
    elo * primeiro;
    public:
    listaT();
    ~listaT();
    listaT(listaT& origem);
};
class elo {
    friend class listaT;
    protected:
    elo();
    elo(unsigned int novaRef, double novoFator, bool x = true, elo * proxElo = NULL);
    elo operator=(const elo& origem);
};
#endif;

在我实现它们的地方，我得到100个或更多的错误。我不明白为什么

#include "planilha.h"
#include <iostream>
#include <cstdlib>
#include <fstream>
using namespace std;
template <class TIPO>
planilha<TIPO>::planilha() {
    primeiro = NULL;
    count = 1;
}
template <class TIPO>
planilha<TIPO>::~planilha(void) {
    celula * p = primeiro;
    while(primeiro!=NULL) {
        p=primeiro->prox;
        delete primeiro
        primeiro=p;
    }
}
template <class TIPO>
planilha<TIPO>::planilha(const planilha<TIPO>& origem) {
    this->count = origem.count;
    celula * p1;
    this->primeiro = NULL;
    celula * p2;
    for(p2 = origem.primeiro; p2!=NULL; p2=p2->prox) {
        p1 = p2;
        if(this->primeiro == NULL) {
            this->primeiro = p1;
        }
        p1 = p1->prox;
    }
}

template <class TIPO>
unsigned int planilha<TIPO>::getCount() const {
    return count;
}
template <class TIPO>
void typename planilha<TIPO>::setCount(unsigned int count) {
    this->count = count;
}
template <class TIPO>
celula * planilha<TIPO>::finder(unsigned int id) {
    celula * resposta;
    for(resposta=this->primeiro; resposta!=NULL; resposta=resposta->prox) {
        if(resposta->idCelula == id) break;
    }
    return resposta;
}
template <class TIPO>
celula<TIPO>::celula() {
    prox = NULL;
}
template <class TIPO>
celula<TIPO>::celula(unsigned int novoId, TIPO novaConstante, planilha<TIPO> * proxCel) {
    idCelula = novoId;
    constante = novaConstante;
    total = novaConstante;
    prox = proxCel;
}

template <class TIPO>
void celula<TIPO>::setTotal(TIPO total) {
    this->total = total;
}

listaT::listaT() {
    this->primeiro = NULL;
}
listaT::~listaT() {
    elo * p = primeiro;
    while(primeiro!=NULL) {
        p=primeiro->prox;
        delete primeiro;
        primeiro=p;
    }
}
listaT::listaT(listaT& origem) {
    elo * p2;
    elo * p1;
    primeiro = NULL;
    for(p2 = origem.primeiro; p2!=NULL; p2 = p2->prox) {
        p1 = p2;
        if(primeiro == NULL) {
            primeiro = p1;
        }
        p1 = p1->prox;
    }
}
bool listaT::vazia() {
    return (primeiro == NULL);
}
void listaT::insere(int novaRef, double novoFator, bool absoluta) {
    elo * p = primeiro;
    elo * novoElo = new elo(novaRef, novoFator, absoluta);
    if(vazia()) {
        primeiro = novoElo;
    } else {
        while(p->prox!=NULL) {
            p = p->prox;
        }
        p->prox = novoElo;
    }
}
bool listaT::operator==(const listaT &listaT2) {
    elo * p1 = this->primeiro;
    elo * p2 = listaT2.primeiro;
    bool resposta = true;
    while(p1!=NULL && p2!=NULL) {
        if(p1->fator != p2->fator || p1->referencia != p2->referencia || p1->absolut != p2->absolut) {
            resposta = false;
        }
        p1=p1->prox;
        p2=p2->prox;
    }
    if(p2!=NULL || p1!=NULL) {
        resposta = false;
    }
    return resposta;
}
elo * listaT::getPrimeiro() {
    elo * resposta;
    resposta = primeiro;
    return resposta;
}
elo::elo() {
    prox = NULL;
}
elo::elo(unsigned int novaRef, double novoFator, bool x, elo * proxElo) {
    referencia = novaRef;
    fator = novoFator;
    prox = proxElo;
    absolut = x;
}
elo elo::operator=(const elo& origem) {
    unsigned int r = origem->referencia;
    double f = origem.fator;
    bool x = origem.absolut;
    elo p(r, f, x);
    return p;
}