[C] Assurdo: Funzione che si ripete senza motivo

[EnergyVortex]

Ciao a tutti, sto finendo un progetto per l'università ma sono bloccato da un problema che mi dà una funzione.
In pratica la funzione è questa:



void attacca (graph* G, edge* A, edge* B, giocatore player[])
{
edge* C=NULL;
C=A->next;
int controlloConfine=0,controllo=1;
if (A->colore==B->colore)
{
printf("Non puoi attaccare un paese sotto il tuo controllo!!!\n");
return;
}
while (C!=NULL && controlloConfine==0)
{
if (C->nome==B->nome)
{
controlloConfine=1;
}
else if (C->next==NULL && C->nome!=B->nome)
{
printf("Attacco impossibile!!!\nI due paesi non confinano!!!\n");
return;

}
else if (C->nome!=B->nome)
{
C=C->next;
}
}
if (controlloConfine==1)
{
printf("\nInizio della fase di attacco: Il giocatore %s attacca dal paese %s con %d armate mentre il giocatore %s dal paese %s si difende con %d armate!\n",stampaNomeGiocatore(stringa,A->colore),stampaNomeTerritorio(stringa,A->nome),A->armate-1,stampaNomeGiocatore(stringa,B->colore),stampaNomeTerritorio(stringa,B->nome),B->armate);
int k,j;
if (A->armate -1 >= 3)
{
k=3;
}
else
{
k=A->armate -1;
}
if (B->armate>= 3)
{
j=3;
}
else
{
j=B->armate;
}
while (B->armate>0 && A->armate>1 && B->colore!=A->colore && controllo == 1)
{
tiraDadi(player,k,A->colore);
tiraDadi(player,j,B->colore);
if (k<=j && controllo==1)
{
confrontaDadi(G,A,B,player,k);
}
else if (k>j && controllo==1)
{
confrontaDadi(G,A,B,player,j);
}

if (B->armate>0 && A->armate>1 && B->colore!=A->colore )
{
printf("Si desidera continuare l'attacco? Digitare 1 per continuare oppure 0 per interrompere!\n");
do
{
scanf("%d",&controllo);
}
while (controllo<0 || controllo>1);
if (controllo == 1)
{
printf("L' attacco continua!!!\n");
attacca(G,A,B,player);
}
else
{
printf("Attacco terminato come richiesto dal giocatore!!!\n");
printf("\n%d\n",controllo);
return;
}
}
}
}
}


che a sua volta chiama questa:


void tiraDadi (giocatore player[], int k, int q)
{
int i,app;

for (i=0; i<k; i++)
{
sleep(750);
player[q].dadi[i]=random(6) + 1;
printf("\nIl giocatore %s tira il dado n.%d e fa %d !!!\n",stampaNomeGiocatore(stringa,q),i+1,player[q].dadi[i]);
}
i=0;
while (i<k-1)
{
if (player[q].dadi[i]<player[q].dadi[i+1])
{
app=player[q].dadi[i];
player[q].dadi[i]=player[q].dadi[i+1];
player[q].dadi[i+1]=app;
i=0;
}

else
{
i++;
}
}
}


e questa:


void confrontaDadi (graph* G,edge* A, edge* B, giocatore player[],int max)
{
int i,j;
for (i=0; i<max; i++)
{
if (player[A->colore].dadi[i]>player[B->colore].dadi[i])
{
printf("\nIl territorio %s perde una unita'!\n",stampaNomeTerritorio(stringa,B->nome));
B->armate--;
player[B->colore].armateDisposte--;
player[B->colore]=controllaAereo(G,player[B->colore]);
if (B->armate==0)
{
printf("Il giocatore %s vince la battaglia e conquista il territorio %s !\n",stampaNomeGiocatore(stringa,A->colore),stampaNomeTerritorio(stringa,B->nome));
for (j=0; j<4; j++)
{
if (player[B->colore].aerei[j].partenza==B->nome)
{
printf("Il giocatore %s ha perso il collegamento aereo che partiva dal territorio %s e arrivava al territorio %s \n", stampaNomeGiocatore(stringa,player[B->colore].colore), stampaNomeTerritorio(stringa,player[B->colore].aerei[j].partenza),stampaNomeTerritorio(stringa,player[B->colore].aerei[j].destinazione));
G->adj[player[B->colore].aerei[j].partenza]=rimuoviCollegamento(G,player[B->colore].aerei[j].partenza,player[B->colore].aerei[j].destinazione);
player[B->colore].aerei[j].destinazione=42;
player[B->colore].aerei[j].partenza=42;
printf("Collegamento rimosso!\n");
}

}
B->colore=A->colore;
int k=0;
while (k<=0 || k>A->armate - 1)
{
printf("Quante armate si desidera spostare nel territorio appena conquistato (tra 1 e %d)???\n",A->armate - 1);
scanf("%d",&k);
}
A->armate=A->armate-k;
B->armate=k;
return;
}
}
else if (player[A->colore].dadi[i]<=player[B->colore].dadi[i])
{
printf("\nIl territorio %s perde una unita'!\n",stampaNomeTerritorio(stringa,A->nome));
A->armate--;
player[A->colore].armateDisposte--;
player[A->colore]=controllaAereo(G,player[A->colore]);
if (A->armate<2)
{
printf("Il giocatore %s interrompe la battaglia e NON conquista il territorio %s ,perchè non ha il numero di unita' necessarie per continuare l'attacco!\n",stampaNomeGiocatore(stringa,A->colore),stampaNomeTerritorio(stringa,B->nome));
return;
}
}
}
}


Il problema sta nella prima funzione, nella parte che ho segnato in grassetto. In pratica quando l'utente decide di interrompere l'attacco la variabile controllo viene impostata a 0 (e viene davvero impostata a 0 da come ho verificato dal printf) quindi il while dovrebbe interrompersi e la funzione ritornare il controllo alla funzione chiamante.
Questo però non succede e per n cicli le funzioni tiradadi e confrontaDadi vengono richiamate n-1 volte, anche se nel ciclo metto un return (che dovrebbe ridare il controllo alla funzione che ha chiamato la funzione attacca).
Sinceramente non so proprio cosa pensare, il codice mi sembra corretto, voi cosa pensate??

[wingman87]

Risiko? Hai provato a cancellare i file oggetto e a ricompilare da zero? E hai provato a vedere cosa succede con un debugger?

Il problema comunque è qui giusto?

printf("Si desidera continuare l'attacco? Digitare 1 per continuare oppure 0 per interrompere!\n");
do
{
scanf("%d",&controllo);
}
while (controllo<0 || controllo>1);
if (controllo == 1)
{
printf("L' attacco continua!!!\n");
attacca(G,A,B,player);
}
else
{
printf("Attacco terminato come richiesto dal giocatore!!!\n");
printf("\n%d\n",controllo);
return;
}

I printf vengono eseguiti ma il return no?

[tacchinox]

Ma è una funzione che chiama se stessa ricorsivamente?

void attacca (graph* G, edge* A, edge* B, giocatore player[])
{
[...]
if (controllo == 1)
{
printf("L' attacco continua!!!\n");
attacca(G,A,B,player);
}
else
{
printf("Attacco terminato come richiesto dal giocatore!!!\n");
printf("\n%d\n",controllo);
return;
}
}
}
}
}

Non è indice di buona programmazione, oltre a portare a comportamenti imprevisti.

Probabilmente fa return a se stessa.

[BlackShark92]

Ma è una funzione che chiama se stessa ricorsivamente?

void attacca (graph* G, edge* A, edge* B, giocatore player[])
{
[...]
if (controllo == 1)
{
printf("L' attacco continua!!!\n");
attacca(G,A,B,player);
}
else
{
printf("Attacco terminato come richiesto dal giocatore!!!\n");
printf("\n%d\n",controllo);
return;
}
}
}
}
}

Non è indice di buona programmazione, oltre a portare a comportamenti imprevisti.

Probabilmente fa return a se stessa.
Va bè, questo no, solo che in questo caso è stata una scelta un pò infelice... la ricorsione è utilissima, prova un pò a fare il gioco delle torri di hanoi senza... :D

[wingman87]

Ma è una funzione che chiama se stessa ricorsivamente?

void attacca (graph* G, edge* A, edge* B, giocatore player[])
{
[...]
if (controllo == 1)
{
printf("L' attacco continua!!!\n");
attacca(G,A,B,player);
}
else
{
printf("Attacco terminato come richiesto dal giocatore!!!\n");
printf("\n%d\n",controllo);
return;
}
}
}
}
}

Non è indice di buona programmazione, oltre a portare a comportamenti imprevisti.

Probabilmente fa return a se stessa.
Hai ragione, quindi si risolve con:

void attacca (graph* G, edge* A, edge* B, giocatore player[])
{
[...]
if (controllo == 1)
{
printf("L' attacco continua!!!\n");
attacca(G,A,B,player);
return;
}
else
{
printf("Attacco terminato come richiesto dal giocatore!!!\n");
printf("\n%d\n",controllo);
return;
}
}
}
}
}

[EnergyVortex]

Ragazzi avete ragione!
Con il return ho risolto tutto!
Sinceramente non sapevo ( o non ricordavo di sapere) che senza il return dopo la chiamata ricorsiva la funzione non terminava "da sola". Come mai?
Cioè se dopo la chiamata ricorsiva non ci sono altre istruzioni, non dovrebbe terminarsi?
Potete spiegarmi perchè è meglio evitare di usare funzioni ricorsive??
Grazie per l'aiuto! Mi stavo scervellando su questa sciocchezza! :D

[wingman87]

Sinceramente io non le trovo indice di alcunché. Certo, ci sono casi in cui una soluzione ricorsiva è più adatta di altre, e nel tuo caso, effettivamente, non so se hai fatto la scelta più "giusta"...
Per quanto riguarda il fatto che non termina da sola il motivo è semplice: la chiamata ricorsiva non è altro che una normale chiamata a funzione e quindi, quando la funzione chiamata termina, il controllo torna al chiamante (e quindi l'esecuzione riparte da dove si era interrotta, per questo serve il return nel tuo caso).