Блог

здесь я определяю свой шаблон и 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>amp; 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);

};
  

Я не знаю, является ли класс friend лучшим вариантом, они используются в классе celula

 class listaT {
    friend class elo;
    protected:
    elo * primeiro;
    public:
    listaT();
    ~listaT();
    listaT(listaTamp; origem);
};

class elo {
    friend class listaT;
    protected:
    elo();
    elo(unsigned int novaRef, double novoFator, bool x = true, elo * proxElo = NULL);
    elo operator=(const eloamp; 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>amp; 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(listaTamp; 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 amp;listaT2) {
    elo * p1 = this->primeiro;
    elo * p2 = listaT2.primeiro;
    bool resposta = true;
    while(p1!=NULL amp;amp; 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 eloamp; origem) {
    unsigned int r = origem->referencia;
    double f = origem.fator;
    bool x = origem.absolut;
    elo p(r, f, x);
    return p;
}
  

Есть ли у вас включение для файлов cpp, и вы убедились, что в противном случае вам нужно поместить исходный код класса шаблона в тот же файл, что и заголовок