Идентификатор, не найденной для этой функции в C ++ ⇐ C++

[Anonymous]

ОК, я написал этот класс, который подсчитывает, сколько листьев в двоичном дереве: < /p>
#ifndef _UTIL_BIN_TREE_H_
#define _UTIL_BIN_TREE_H_

#include"bin_treec.h"

template
class util_bin_tree
{

public:
static int n_leaf(const Bin_treec& T) {
int i;
if (!T.empty())
{
if (T->spazio.sinistro == NULL && T->spazio.destro == NULL)
return 1;
else
return n_leaf(T->T->spazio[i + i].sinistro) + n_leaf(T->T->spazio[i + i].destro);
}
};
static int n_level(const Bin_treec& T, int i)
{
//
};
};

#endif
< /code>
Это класс, который создает двоичное дерево: < /p>
#ifndef _Bin_treecC_H_
#define _Bin_treecC_H_

#include "Bin_tree.h"
#include "exceptions.h"

template
class Bin_treec : public Bin_tree {
static const int NIL = -1;

public:

typedef typename Bin_tree::value_type value_type;
typedef typename Bin_tree::Nodo Nodo;

struct _cella {
Nodo genitore;
Nodo sinistro;
Nodo destro;
value_type valore;
};

typedef struct _cella Cella;

// costruttori e distruttori
Bin_treec();
Bin_treec(int);
~Bin_treec();

// operatori
void create();
bool empty() const;

Nodo root() const;
Nodo parent(Nodo) const;
Nodo sx(Nodo) const;
Nodo dx(Nodo) const;
bool sx_empty(Nodo) const;
bool dx_empty(Nodo) const;

//void costr(Bin_treec);
void erase(Nodo);

T read(Nodo) const;
void write(Nodo, value_type);

void ins_root();
void ins_sx(Nodo);
void ins_dx(Nodo);

private:
int MAXLUNG;
Cella* spazio;
int nNodi;
Nodo inizio;
Nodo libera;
};

template
Bin_treec::Bin_treec()
{
MAXLUNG = 100;
spazio = new Cella[MAXLUNG];
create();
}

template
Bin_treec::Bin_treec(int nNodi) : MAXLUNG(nNodi)
{
spazio = new Cella[nNodi];
create();
}

template
Bin_treec::~Bin_treec()
{
erase(inizio);
delete[] spazio;
}

template
void Bin_treec::create()
{
inizio = NIL;
for (int i = 0; i < MAXLUNG; i++)
{
spazio.sinistro = (i + 1) % MAXLUNG;
}

libera = 0;
nNodi = 0;
}

template
bool Bin_treec::empty() const
{
return(nNodi == 0);
}

template
typename Bin_treec::Nodo Bin_treec::root() const
{
return(inizio);
}

template
typename Bin_treec::Nodo Bin_treec::parent(Nodo n) const
{
if (n != inizio)
return (spazio[n].genitore);
else
return(n);
}

template
typename Bin_treec::Nodo Bin_treec::sx(Nodo n) const
{
if (!sx_empty(n))
return (spazio[n].sinistro);
else
return(n);
};

template
typename Bin_treec::Nodo Bin_treec::dx(Nodo n) const
{
if (!dx_empty(n))
return (spazio[n].destro);
else
return(n);
}

template
bool Bin_treec::sx_empty(Bin_treec::Nodo n) const
{
return (spazio[n].sinistro == NIL);
}

template
bool Bin_treec::dx_empty(Bin_treec::Nodo n) const
{
return (spazio[n].destro == NIL);
}

template
void Bin_treec::ins_root()
{
if (inizio == NIL)
{

inizio = libera;
libera = spazio[libera].sinistro;
spazio[inizio].sinistro = NIL;
spazio[inizio].destro = NIL;
nNodi++;
}
else
throw RootExists();
}

template
void Bin_treec::ins_sx(Nodo n)
{
if (inizio == NIL)
throw EmptyTree();
if (n == NIL)
throw NullNode();
if (spazio[n].sinistro != NIL)
throw NodeExists();
if (nNodi >= MAXLUNG)
throw FullSize();
else
{
Nodo q = libera;
libera = spazio[libera].sinistro;
spazio[n].sinistro = q;
spazio[q].sinistro = NIL;
spazio[q].genitore = n;
spazio[q].destro = NIL;
nNodi++;
}
}

template
void Bin_treec::ins_dx(Nodo n)
{
if (inizio == NIL)
throw EmptyTree();
if (n == NIL)
throw NullNode();
if (spazio[n].destro != NIL)
throw NodeExists();
if (nNodi >= MAXLUNG)
throw FullSize();
else
{
Nodo q = libera;
libera = spazio[libera].sinistro;
spazio[n].destro = q;
spazio[q].genitore = n;
spazio[q].sinistro = NIL;
spazio[q].destro = NIL;
nNodi++;
}
}

template
void Bin_treec::erase(Nodo n)
{
if (n != NIL) {
if (!sx_empty(n))
erase(spazio[n].sinistro);
if (!dx_empty(n))
erase(spazio[n].destro);
if (n != inizio) {
Nodo p = parent(n);
if (spazio[p].sinistro == n)
spazio[p].sinistro = NIL;
else
spazio[p].destro = NIL;
}
else
inizio = NIL;
nNodi--;
spazio[n].sinistro = libera;
libera = n;
}
else
throw NullNode();
}

template
T Bin_treec::read(Nodo n) const
{
if (n != NIL)
return (spazio[n].valore);
else
throw NullNode();
}

template
void Bin_treec::write(Nodo n, value_type a)
{
if (n != NIL)
spazio[n].valore = a;
else
throw NullNode();
}

#endif /* _Bin_treecC_H_ */
< /code>
Это основной < /p>
#include "util_bin_tree.h"
#include

using namespace std;

int main() {
Bin_treec T;
typename Bin_treec::Nodo n1 = 0, n2 = 0;

T.ins_root();
T.write(T.root(), 1);
n1 = T.root();
T.ins_sx(n1);
T.ins_dx(n1);
T.write(T.sx(n1), 2);
n1 = T.dx(n1);
T.write(n1, 3);
T.ins_dx(n1);
T.write(T.dx(n1), 4);
T.print();
cout
говорит, что моя функция не выявлена, но я не знаю, почему.
Полная ошибка: < /p>
Severity Code Description Project File Line Suppression State
Error C3861 'n_leaf': identifier not found esercizio C:\Users\mypc\source\repos\esercizio\test.cpp 26

< /code>
У меня также есть заголовок виртуального bin_tree, где util_bin_tree не указан, но я не думаю, что это действительно важно, потому что я не использую какие -либо функции, связанные с деревом. Я просто хотел передать весь объект другой функции класса, и компилятор не находит никакой ошибки на данный момент. Но я не могу проверить функцию только из -за этой проблемы. Есть помощь?

Подробнее здесь: https://stackoverflow.com/questions/600 ... ction-in-c