Newsgroup: it.comp.lang.c++
Titolo: Return nelle funzioni ricorsive

Salve,
ho questo semplice codice in cui, partendo da una stringa e da un valore 
intero, popolo un albero creando un nodo per ogni carattere della stringa e 
assegnando il valore intero al nodo relativo all'ultimo carattere. Ma nel 
momento in cui voglio stampare il valore associato a tale stringa, la 
funzione non si comporta come dovrebbe. Infatti se provo a stampare il 
valore dall'interno della funzione il valore � corretto, ma se uso return, 
restituisce un altro valore (che non esiste nell'albero), un po' come se la 
funzione nonostante il return, continuasse a invocare se stessa. Non c'e' un 
modo per avere un return che annulli tutte le invocazioni in corso su se 
stessa che la funzione ha eseguito?
La funzione a cui mi riferisco si chiama "valore". La funzione inserisci 
popola l'albero e la struct S rappresenta i nodi.
#include <iostream>
#include <string>
#include <vector>
using namespace std;
struct S {
    char ch;
    int val;
    vector<S*> v;
    S(char c) {
        ch = c;
        val = 0;
    }
    void set(int i) {
        val = i;
    }
    ~S() {
        for (int i = 0; i < v.size(); i++)
            delete v[i];
    }
};
vector<S*> r;
void inserisci(string str, vector<S*>& s, int val = 0, int i = 0) {
    if (i < str.size()) {
        int pos = -1;
        for (int j = 0; j < s.size(); j++)
            if (s[j]->ch == str[i])
                pos = j;
        if (pos == -1) {
            s.push_back(new S(str[i]));
            if (i == str.size() - 1)
                s.back()->set(val);
            inserisci(str, s.back()->v, val, i + 1);
        }
        else {
            if (i == str.size() - 1)
                s[pos]->set(val);
            inserisci(str, s[pos]->v, val, i + 1);
        };
    };
}
int valore (string str, vector<S*> r, int i = 0) {
    if (i < str.size()) {
        for (int j = 0; j < r.size(); j++) {
            if (str[i] == r[j]->ch) {
                if (i == str.size() - 1) {
                    cout << r[j]->val << endl;
                    return r[j]->val;
                }
                else
                    valore(str, r[j]->v, i + 1);
            };
        };
    };
}
int main() {
    inserisci("ABC", r, 10);
    cout << valore("ABC", r) << endl;
    for (int i = 0; i < r.size(); i++)
        delete r[i];
    return 0;
}
 

 popola l'albero e la struct S rappresenta i nodi.
Ho risolto facendo uso una variabile statica, ma non c'e' un modo più 
elegante?
// Considero -1 il valore da ritornare quando non c'è un valore associato 
alla stringa
int valore (string str, vector<S*> r, int i = 0) {
    static int val = -1;
    if (i < str.size())
        for (int j = 0; j < r.size(); j++)
            if (str[i] == r[j]->ch)
                if (i == str.size() - 1)
                    val = r[j]->val;
                else {
                    val = -1;
                    valore(str, r[j]->v, i + 1);
                };
    return val;
}
 

 corretto, ma se uso return, restituisce un altro valore
Questo succede perché il risultato della chiamata ricorsiva a valore 
viene scartato:
else
     valore(str, r[j]->v, i + 1);
invece devi ritornare quel valore.
P.S.
Lo so, potrei indicarti subito la soluzione, ma secondo me impari meglio 
se ci arrivi da solo con qualche suggerimento.
Ciao.
-- 
http://www.econet-project.eu

 se ci arrivi da solo con qualche suggerimento.
Giusto, devo sempre chiamare return altrimenti le chiamate annidate 
sarebbero prive di un return mentre invece ne hanno bisogno avendo tutte int 
come tipo di ritorno. Ho risolto cosě:
int valore (string str, vector<S*> r, int i = 0) {
    if (i < str.size())
        for (int j = 0; j < r.size(); j++)
            if (str[i] == r[j]->ch)
                if (i == str.size() - 1)
                    return r[j]->val;
                else
                    return valore(str, r[j]->v, i + 1);
    return -1;
}
Grazie