Question

这是我定义我的模板和另外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);

};

我不知道朋友班是否是最好的选择，这些是在课堂上使用的

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

Answer 1

您是否有cpp文件的包含，并确保如果您不需要将模板类源代码放在与标题相同的文件中

我的模板不工作（C ++） - 我做错了什么？

1 个答案: