Dubbio c++

Salve, ho risolto la seguente traccia:

1 Traccia
Realizzare e completare in C++ la seguente classe che implementa metodi operanti su un albero n-ario.
Prevedere una funzione main che contenga una procedura di inserimento automatico e successivamente il
test dei metodi implementati.
template<class _value_type>
class util_n_tree{
/* Restituisce il numero di foglie presenti nell’albero n-ario T */
int n_leaf(const tree< _value_type > &T);
/* Restituisce il numero di nodi in T di livello k */
int n_level(const tree< _value_type > &T, int k);
};

nel seguente modo:

#ifndef UTIL_N_TREE_H_
#define UTIL_N_TREE_H_

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

template<class _value_type>
class util_n_tree
{
public:
    typedef typename Albero< _value_type >::nodo nodo;
    /* Restituisce il numero di foglie presenti nell’albero n-ario T */
    int n_leaf(const Albero< _value_type > &T);
    /* Restituisce il numero di nodi in T di livello k */
    int n_level(const Albero< _value_type > &T, int k);
private:
    void n_leaf(const Albero< _value_type > &T, nodo n, int &sum_leaves);
    void n_level(const Albero< _value_type > &T, nodo n, int &sum_leaves, int lev);
};

template<class _value_type>
int util_n_tree<_value_type>::n_leaf(const Albero< _value_type > &T)
{
    int sum = 0;

    if(!T.vuoto())
        n_leaf(T, T.radice(), sum);

    return sum;

}

template<class _value_type>
void util_n_tree<_value_type>::n_leaf(const Albero< _value_type > &T, nodo n, int &sum_leaves)
{
    if (T.foglia(n))
        sum_leaves += 1;
    if(!T.foglia(n))
        n_leaf(T, T.primo_figlio(n), sum_leaves);
    if(!T.ultimo_fratello(n))
        n_leaf(T, T.fratello_succ(n), sum_leaves);
}

template<class _value_type>
int util_n_tree<_value_type>::n_level(const Albero< _value_type > &T, int k)
{
    int sum = 0;

    if(!T.vuoto())
        n_level(T, T.radice(), sum, k);

    return sum;
}

template<class _value_type>
void util_n_tree<_value_type>::n_level(const Albero< _value_type > &T, nodo n, int &sum_leaves, int lev)
{
    if (T.livello(n) == lev)
        sum_leaves += 1;
    if(!T.foglia(n))
        n_level(T, T.primo_figlio(n), sum_leaves, lev);
    if(!T.ultimo_fratello(n))
        n_level(T, T.fratello_succ(n), sum_leaves, lev);
}

#endif // UTIL_N_TREE_H_

Tutto funziona, ma vorrei sapere se è stata una scelta adeguata inserire come membri privati le seguenti sottofunzioni:

void n_leaf(const Albero< _value_type > &T, nodo n, int &sum_leaves);
void n_level(const Albero< _value_type > &T, nodo n, int &sum_leaves, int lev);

Potrei migliorare in qualche modo il codice? Grazie.