C++ 我的模板不起作用（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
};

在这里我实现了它们，我得到了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;
}

#包括“planilha.h”
#包括
#包括
#包括
使用名称空间std；
模板
planilha：：planilha（）{
primeiro=NULL；
计数=1；
}
模板
planilha:：~planilha（无效）{
celula*p=primeiro；
while（primeiro！=NULL）{
p=primeiro->prox；
删除primeiro
primeiro=p；
}
}
模板
planilha：：planilha（const planilha&origem）{
此->计数=origem.count；
celula*p1；
此->primeiro=NULL；
celula*p2；
对于（p2=origem.primeiro；p2！=NULL；p2=p2->prox）{
p1=p2；
如果（此->primeiro==NULL）{
这->primeiro=p1；
}
p1=p1->prox；
}
}
模板
unsigned int planilha:：getCount（）常量{
返回计数；
}
模板
void typename planilha:：setCount（无符号整数计数）{
这个->计数=计数；
}
模板
celula*planilha:：finder（无符号整数id）{
塞鲁拉*resposta；
对于（resposta=this->primeiro；resposta！=NULL；resposta=resposta->prox）{
如果（resposta->idCelula==id）中断；
}
返回响应；
}
模板
celula：：celula（）{
prox=NULL；
}
模板
塞卢拉：塞卢拉（未签名的诺沃德，新君士坦特，普莱尼尔哈*普罗塞尔）{
Idcella=novoId；
君士坦特=新君士坦特；
总计=新康斯坦特；
prox=proxCel；
}
模板
void celula:：setTotal（TIPO总计）{
此->总计=总计；
}
listaT:：listaT（）{
此->primeiro=NULL；
}
listaT:：~listaT（）{
elo*p=primeiro；
while（primeiro！=NULL）{
p=primeiro->prox；
删除primeiro；
primeiro=p；
}
}
listaT:：listaT（listaT&origem）{
elo*p2；
elo*p1；
primeiro=NULL；
对于（p2=origem.primeiro；p2！=NULL；p2=p2->prox）{
p1=p2；
if（primeiro==NULL）{
primeiro=p1；
}
p1=p1->prox；
}
}
bool listaT:：vazia（）{
返回值（primeiro==NULL）；
}
虚空列表：：插图（整数novaRef、双novoFator、布尔绝对值）{
elo*p=primeiro；
elo*novoElo=新elo（novaRef、novoFator、absoluta）；
if（vazia（））{
primeiro=novoElo；
}否则{
而（p->prox！=NULL）{
p=p->prox；
}
p->prox=novoElo；
}
}
bool listaT:：operator==（常量listaT和listaT2）{
elo*p1=此->primeiro；
elo*p2=listaT2.primeiro；
bool resposta=true；
而（p1！=NULL&&p2！=NULL）{
如果（p1->fator！=p2->fator | p1->referencea！=p2->referencea | p1->absolut！=p2->absolut）{
resposta=false；
}
p1=p1->prox；
p2=p2->prox；
}
如果（p2！=NULL | | p1！=NULL）{
resposta=false；
}
返回响应；
}
elo*listaT:：getPrimeiro（）{
elo*resposta；
resposta=primeiro；
返回响应；
}
elo：：elo（）{
prox=NULL；
}
elo:：elo（无符号整数novaRef、双novoFator、布尔x、elo*proxElo）{
referencia=novaRef；
fator=novoFator；
prox=proxElo；
绝对值=x；
}
elo elo:：运算符=（常量elo和origem）{
无符号整数r=origem->referencia；
双f=origem.fator；
bool x=origem.absolut；
elo p（r，f，x）；
返回p；
}

您是否有cpp文件的include，如果没有，是否确保需要将模板类源代码与头文件放在同一个文件中

此问题有10亿个副本。请将代码减少到显示问题的最简单版本。阅读编译器的抱怨，并修复所有错误和警告。最后，您的程序将编译。顺便说一句，错误是什么？在“请发布错误消息、实际问题和10倍以下无用代码”之前，预期的构造函数、析构函数或类型转换。我的老师告诉我用定义制作一个文件，用方法制作另一个文件。我所有的文件都是两个.h文件和一个main.cpp，包括这两个标题通常，您确实需要将源文件与.h文件中类template的头文件放在同一个文件中，尝试将#包括您的.cpp文件放在我的类定义中，并且对于template类，方法的实际实现应该放在一个.h文件中？

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;

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