Newsgroup: it.comp.lang.c++
Titolo: Perchè all'interno di una classe....

....le funzioni che realizzano un comportamento ricorsivo hanno bisogno di
una funzione interna di servizio da richiamare?
Non sarebbe possibile fare in modo che una funzione ricorsiva lavori senza
questo aiuto esterno?
E se no(come credo) per quali motivi?
Grazie anticipatamente!


E questo dove sta scritto?!
class Neverending {
  public:
    void story() { story(); }
};
Piu' ricorsivo di cosi'...
Ciao,
Nicola

> E questo dove sta scritto?!
Sul mio libro("Da C++ a UML") viene spiegato che un membro che realizza
un'algoritmo ricorsivo(ad esempio una funzione ricerca, in un albero
binario) deve essere realizzato attraverso un membro publico che viene
chiamato direttamente
dall'utente, e un membro privato che realizza la ricorsione.
Secondo te è possibile fare la stessa cosa anche con una funzione publica
che richiama se stessa passando(nel caso dell'albero binario) i nodi
successivi dell'albero?



#include <iostream>
class Class {
  public:
     void membro_pubblico(int i) {
          if (i) {
             std::cout << "butta quel libroooo !!! "
                       << std::endl;
             membro_pubblico(i - 1);
          }
     }
};
int main()
{
    Class MyClass;
    MyClass.membro_pubblico(20);
    return 0;
}
-- 
Andrea Laforgia - walkietalkie(at)
libero.it
"Meglio cieco che negro" (Stevie Wonder)

 i nodi successivi dell'albero?
Il codice che ha postato Nicola è legale e questo risponde implicitamente
alla tua domanda, mi pare.
Max

chiamato direttamente
A mio avviso stai facendo confusione fra una tecnica spiegata
dall'autore per realizzare algoritmi basati sulla ricorsione con le
regole del linguaggio.
Il Ghenio
---------
// TODO: Place your ass here

 wrote in message
news:O3f38.31141$tl3.9...@twister2.libero.it...

Credo che il caso a cui fa riferimento il tuo libro sia
il seguente (l'ho compilato con C++ Builder e non e' 
ottimizzato per niente):
<CODE>
#include <iostream>
typedef struct tree_node {
               std::string s;
               struct tree_node *left, *right;
        } tree_node, *ptree_node;
class BinTree {
      private:
        ptree_node Root;
        void insert_string(ptree_node& p, std::string s);
        void write_tree(ptree_node p);
        void destroy_tree(ptree_node& p);
        bool find_string(ptree_node p, std::string s);
      public:
        // costruttore
        BinTree() { Root = 0; }
        // distruttore
        ~BinTree() { destroy_tree(Root); }
        void Write();
        void InsertString(std::string s);
        bool FindString(std::string s);
};
void BinTree::insert_string(ptree_node& p,
                            std::string s)
{
     if (!p)
     {
        p = new tree_node;
        p->s = s;
        p->left = p->right = 0;
     }
     else
     if (s <= p->s)
       insert_string(p->left, s);
     else
       insert_string(p->right, s);
}
void BinTree::write_tree(ptree_node p)
{
     if (p)
     {
        write_tree(p->left);
        std::cout << p->s << "; " ;
        write_tree(p->right);
     }
}
void BinTree::destroy_tree(ptree_node& p)
{
     if (p)
     {
        destroy_tree(p->left);
        destroy_tree(p->right);
        delete p;
        p = 0;
     }
}
bool BinTree::find_string(ptree_node p, std::string s)
{
     if (p)
     {
        if (s == p->s)
          return true;
        else
        if (s < p->s)
          return find_string(p->left, s);
        else
          return find_string(p->right, s);
     }
     else
       return false;
}
//
// interfaccia
//
void BinTree::Write()
{
     write_tree(Root);
     std::cout << std::endl;
}
void BinTree::InsertString(std::string s)
{
     insert_string(Root, s);
}
bool BinTree::FindString(std::string s)
{
     return find_string(Root, s);
}
int main()
{
    BinTree MyBinaryTree;
    MyBinaryTree.InsertString("elefante");
    MyBinaryTree.InsertString("dado");
    MyBinaryTree.InsertString("mucca");
    MyBinaryTree.InsertString("farfalla");
    MyBinaryTree.InsertString("libro");
    MyBinaryTree.InsertString("imbuto");
    MyBinaryTree.InsertString("zattera");
    MyBinaryTree.InsertString("barca");
    MyBinaryTree.InsertString("gatto");
    MyBinaryTree.InsertString("armadio");
    MyBinaryTree.Write();
    std::string s;
    std::cout << "Stringa da cercare: ";
    std::cin >> s;
    if (MyBinaryTree.FindString(s))
      std::cout << "Stringa trovata !" ;
    else
      std::cout << "Stringa non trovata !";
    std::cout << std::endl;
    char c;
    std::cin >> c;
    return 0;
}
</CODE>
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

Ok, credo di aver capito il concetto: sintatticamente il linguaggio lo
consente(questo sul libro non sta scritto!), ma per una migliore tecnica di
programmazione può essere meglio far si che delle funzionalità interne alla
classe siano realizzate in membri privati e quindi nel caso dell'albero, la
funzione ricerca è chiamata dall'utente, ma la ricorsione la realizza un
membro privato.
Grazie a tutti!


Riferendomi anche all'esempio di Andrea in questo caso specifico la
soluzione suggerita dal tuo libro e' inevitabile, perche' la funzione
ricorsiva deve passarsi come parametro un membro privato della classe,
al quale gli utenti non devono avere accesso.
Ciao,
Nicola

ottimizzato per niente):
Sarà forse perché passi per valore delle std::string a delle funzioni
e ci sono un sacco di costruttori e distruttori in più.


 e ci sono un sacco di costruttori e distruttori in più.
Non l'ho capita...


 ha scritto nel messaggio
news:3c4da7a...@news.tin.it...
: On Tue, 22 Jan 2002 14:55:42 GMT, "Max"


(3) evitare che l'utente chiami la procedura ricorsiva in maniera sbagliata
<maxi-snip>
E' esattamente cio' che e' contenuto nel mio messaggio piu'
sotto, in cui c'e' un esempio concreto di quanto dici ;)
