Weierstrass ha scritto:
Zack909 ha scritto:
Weierstrass ha scritto:
Si può fare questo che funziona una volta sola, ma per me è cattiva programmazione
insieme * intersezione(insieme i1, insieme i2)
{
int k, j;
double temp;
static insieme * ret = NULL;
static unsigned int step = 0;
for(k = step; k < i1.l; k++)
for(j = step; j < i2.l; j++)
if(ret == NULL && i1.a[k] == i2.a[j])
{
temp = i1.a[step];
i1.a[step] = i1.a[k];
i1.a[k] = temp;
temp = i2.a[step];
i2.a[step] = i2.a[j];
i2.a[j] = temp;
step++;
intersezione(i1, i2);
}
if(ret == NULL)
{
ret = (insieme *)malloc(sizeof(insieme));
ret->l = step;
if(step){
ret->a = (double *)malloc(step*sizeof(double));
while(step--)
ret->a[step] = i1.a[step];
}
else
ret->a = NULL;
return ret;
}
}
Ottimo!! Funziona!! Ma in che senso una volta sola?
Che le variabili static hanno un valore sbagliato la seconda volta che tenti di fare l'intersezione di due insiemi, quindi la funzione si può usare una volta sola.
Secondo me "return intersezione" è una chiamata ricorsiva e automaticamente deve esserci un punto di uscita dalla ricorsione, quindi il return vero. Probabilmente il professore intendeva di non mettere altri return value a caso oltre al minimo necessario. Si possono fare barbatrucchi come quello mostrato sopra, ma perché? Se scrivete una funzione così al lavoro vi licenziano
Guarda, sono pienamente d'accordo ma non ci possiamo fare niente purtroppo...
Questo è un estratto delle limitazioni:
Coerente coi principi della programmazione strutturata:
* Privo di istruzioni goto.
* Privo di istruzioni exit.
* Privo di istruzioni continue.
* Privo di istruzioni break che non si trovano alla fine di un case di uno switch.
* Privo di molteplici istruzioni return nel corpo della stessa funzione.
Spero intenda di non metterne troppi, ma conoscendolo ne dubito...
Poi scusa l'ignoranza ma while(step--) sarebbe che esegue le istruzioni finché step non arriva a 0?