在 C++ 中找不到此函数的标识符

Question

Ok i wrote this class that counts how many leaves are there in a binary tree:

#ifndef _UTIL_BIN_TREE_H_
#define _UTIL_BIN_TREE_H_

#include"bin_treec.h"


template <class T>
class util_bin_tree
{

public:
    static int n_leaf(const Bin_treec<T>& T) {
        int i;
        if (!T.empty())
        {
            if (T->spazio[i].sinistro == NULL && T->spazio[i].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>& T, int i)
    {
          //
    };
};


#endif

this is the class that creates the binary tree:

#ifndef _Bin_treecC_H_
#define _Bin_treecC_H_

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




template <class T>
class Bin_treec : public Bin_tree<T, int> {
    static const int NIL = -1;

public:

    typedef typename Bin_tree<T, int>::value_type value_type;
    typedef typename Bin_tree<T, int>::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<T>);
    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 <class T>
Bin_treec<T>::Bin_treec()
{
    MAXLUNG = 100;
    spazio = new Cella[MAXLUNG];
    create();
}

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


template <class T>
Bin_treec<T>::~Bin_treec()
{
    erase(inizio);
    delete[] spazio;
}

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

    libera = 0;
    nNodi = 0;
}

template <class T>
bool Bin_treec<T>::empty() const
{
    return(nNodi == 0);
}

template <class T>
typename Bin_treec<T>::Nodo Bin_treec<T>::root() const
{
    return(inizio);
}

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

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

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

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

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

template <class T>
void Bin_treec<T>::ins_root()
{
    if (inizio == NIL)
    {

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


template <class T>
void Bin_treec<T>::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 <class T>
void Bin_treec<T>::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 <class T>
void Bin_treec<T>::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 <class T>
T Bin_treec<T>::read(Nodo n) const
{
    if (n != NIL)
        return (spazio[n].valore);
    else
        throw NullNode();
}

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


#endif /* _Bin_treecC_H_ */

this is the main

#include "util_bin_tree.h"
#include <iostream>

using namespace std;


int main() {
    Bin_treec<int> T;
    typename Bin_treec<int>::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 << T;
    n_leaf(T); // here i have error C3681

It says that my function is undeclared but i don't know why. Full error is :

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  

I also have a virtual bin_tree header where util_bin_tree is not specified, but I don't think it really matters because i don't use any functions related to the tree. Also, is it my way to pass an array from T correct? I just wanted to pass an entire object to another class function and the compiler doesn't find any error for the time being. But i can't test the function just because of that problem. Any help?

Answer 1

Your n_leaf function is not a namespace-scoped function, it's a static function inside the util_bin_tree class. You can call it with util_bin_tree<int>::n_leaf(T) .

Since your util_bin_tree class does not have any data members, you could use namespace util_bin_tree { } instead, and put template<class T> before each function.