Scusami ma ancora non comprendo ciò che hai fatto
Innanzitutto per semplificare il tutto ho utilizzato un array di interi, visto che, come già detto nell'altro post, non ha quasi mai senso fare
double1 == double2.
Infatti per valutare l'uguaglianza tra due valori in virgola mobile si ricorre di solito a qualcosa del genere
|double1-double2|<€
dove € è l'errore relativo ritenuto accettabile.
bool è un tipo che può assumere solo due valori: true (corrispondente a 1) e false (corrispondente a 0). Nel casting da int a bool, tutti i valori diversi da 0 vengono convertiti in true, mentre 0 viene convertito in false.
Per quanto riguarda la condizione dell'if (ti faccio notare che !v[0] coincide con v[0]==0):
- se risulta falsa si verifica un'ulteriore chiamata ricorsiva (ossia fun(&(--v[0]), n));
- se risulta vera il processo ricorsivo si interrompe e viene ritornato (return v[0]) la conversione in bool (essendo bool il tipo di ritorno della funzione) dell'intero costituito da v[0]. In particolare:
* v[0]==0 (ossia l'array non contiene alcun elemento uguale ad n) ==> return 0;
* v[v[0]]==n (ossia l'array contiene almeno un elemento uguale ad n) ==> return 1.
Concentriamoci ora sulla chiamata ricorsiva fun(&(--v[0]), n). In pratica gli passo sempre lo stesso array, infatti l'identificatore dell'array v coincide con l'indirizzo di memoria (che prelevo con l'operatore &) del primo elemento (ossia v[0]), ma ad ogni chiamata ricorsiva diminuisco di 1 (--v[0]) il valore del primo elemento, in modo che vado a considerare tutti gli elementi dell'array a partire dall'ultimo fino al secondo (ossia v[1]).
Consideriamo infine l'espressione return fun(&(--v[0]), n) * ++v[0]. Essa ritornerà lo stesso valore ritornato dal return all'interno dell'if, infatti considerando che ++v[0] assumerà valori che vanno da 1 fino al valore originale di v[0] (pari al numero di elementi dell'array -1) avremo che:
- se l'if ritorna 0 allora return fun(&(--v[0]), n) * ++v[0] ritornerà sempre 0, in quanto il prodotto tra 0 e un numero positivo è uguale a 0;
- se l'if ritorna 1 allora return fun(&(--v[0]), n) * ++v[0] ritornerà sempre 1, in quanto il prodotto tra 1 e un numero positivo è uguale ad un numero positivo che convertito in bool restituisce 1.
Lo scopo di moltiplicare per ++v[0] è quello di incrementare nella fase di "ritorno" della ricorsione il valore di v[0] decrementato nella fase di "andata".
ed in una funzione posso usare solo 1 return.
E come mai?!
In ogni caso non sarebbe difficile aggiustare il tiro:
bool fun(int *v, int n)
{
bool flag = v[0];
if(flag && v[v[0]] != n)
{
flag = fun(&(--v[0]), n) * ++v[0];
}
return flag;
}
Questo ragionamento potrebbe funzionare?
Prova a tradurlo in codice e ti faccio sapere, anche se ho qualche dubbio al riguardo... il problema è che ti serve cmq un altro argomento o variabile statica/globale che tenga conto di quella che tu chiami ultpos!
Ciao, ho provato di nuovo a capire la tua funzione, mi ritrovo in difficoltà in quanto su ANSI C non è presente il tipo bool
Premesso che non so di preciso cosa si intenda con ANSI C, non è comunque difficile simulare il tipo bool con un int, ti faccio inoltre presente che esiste la libreria stdbool.h per utilizzare i valori booleani anche nel C.
il compilatore mi riporta l'errore:
...
Non saprei, devo pensarci!
Magari qualcun altro ti saprà rispondere.
non posso utilizzare variabili globali e più di una funzione return nella stessa funzione.
Comunque grazie per il supporto, provo a seguire la strada della funzione supplementare consigliata da Andrea
Ok, nel caso dopo ci penso e ti posto qualche "input".