[C ++] Funzioni ricorsive

[stestisa]

Ciao a tutti.

Mi sono imbattuto ieri in due funzioni ricorsive, di cui non riesco a capirne la differenza (se non a differenza di codice).

La prima funziona è la stampa di un array:

void stampa(float A[],int dim) {  
   if (dim == 0){
      return;
   } else {
      stampa(A, dim-1);
      cout << A[dim-1] << " ";
   }
}

La seconda invece è la stampa di un array invertendone l'ordine:

void stampa_contrario(float A[],int dim) {  
   if (dim == 0){
      return;
   } else {
      cout << A[dim-1] << " ";
      stampa_contrario(A, dim-1);
   }
}

C'è qualche buon'anima che mi spiega come funzionano questa funzioni? Nel senso, perché nella funzione stampa viene prima richiamata per ricorsione la medesima funzione e poi viene fatto un cout, mentra nella funzione stampa_contrario viene appunto invertito l'ordine?

Una spiegazione a livello visivo di come agiscono queste due funzioni penso che mi risolverebbe molto le cose.

Grazie mille a tutti quanti risponderanno.

Stefano

[valia]

per avere la stampa in due ordini: primo da 0 a dimensione e poi da dimensione a 0.

[stestisa]

Originariamente inviato da valia
per avere la stampa in due ordini: primo da 0 a dimensione e poi da dimensione a 0.

Ma a me sembra che parta sempre dalla dimensione massima e man mano scenda verso la posizione 0. In entrambe le funzioni parte da (dim-1), dove dim è la dimensione massima. Non riesco proprio a capire a livello grafico come funzioni.
A vederlo tramite i miei occhi la macchina fa la stessa identica cosa. Però eseguendolo, vedo che non è la stessa cosa.

[valia]

appunto, perché in un caso chiama la funzione con il restante array e continua fino a quando non sto chiamando quello alla posizione 0.

void stampa(float A[],int dim) {  
   if (dim == 0){
      return;
   } else {
      stampa(A, dim-1);
      cout << A[dim-1] << " ";
   }
}

La stampa a video avviene DOPO aver finito di scorrere l'array, se hai un array di 3 elementi, fai

1. dim = 3, chiami stampa con l'array e dim = 2
2. dim = 2 chiami stampa con l'array e dim = 1
3. dim = 1 chiami stampa con l'array dim = 0
4. dim = 0 ritorni --> ritorni dalla chiamata 3 (l'ultima), quindi stampi l'elemento alla posizione dim-1 (cioè la posizione 0), il primo elemento.
Fatta la stampa finisci
5. è finita la chiamata alla stampa fatta con dim = 2, stampi il precedente (la posizione 1)
e via dicendo.

prova a fare quello che ho fatto sopra io nel caso in cui hai scambiato le posizioni (l'altra stampa)

[stestisa]

Originariamente inviato da valia
appunto, perché in un caso chiama la funzione con il restante array e continua fino a quando non sto chiamando quello alla posizione 0.

void stampa(float A[],int dim) {  
   if (dim == 0){
      return;
   } else {
      stampa(A, dim-1);
      cout << A[dim-1] << " ";
   }
}

La stampa a video avviene DOPO aver finito di scorrere l'array, se hai un array di 3 elementi, fai

1. dim = 3, chiami stampa con l'array e dim = 2
2. dim = 2 chiami stampa con l'array e dim = 1
3. dim = 1 chiami stampa con l'array dim = 0
4. dim = 0 ritorni --> ritorni dalla chiamata 3 (l'ultima), quindi stampi l'elemento alla posizione dim-1 (cioè la posizione 0), il primo elemento.
Fatta la stampa finisci
5. è finita la chiamata alla stampa fatta con dim = 2, stampi il precedente (la posizione 1)
e via dicendo.

prova a fare quello che ho fatto sopra io nel caso in cui hai scambiato le posizioni (l'altra stampa)

Con il codice:

void stampa_contrario(float A[],int dim) {  
   if (dim == 0){
      return;
   } else {
      cout << A[dim-1] << " ";
      stampa_contrario(A, dim-1);
   }
}

e un ipotetico array di 3 elementi
vieni quindi:
1: stampa il terzo elemento, posizione 2
2: stampa il secondo elemento, posizione 1
3: stampa il primo elemento, posizione 0.

E poi esce. Giusto?

Ma perché nella funzione stampa, quando arriva a 0, inizia a stampare la posizione 0, poi 1, poi 2?
Cioè, chi gli dice di andare a stampare anche la posizione 1 e 2? E quel "return" indicato se dim==0, non fa ripartire la funzione? Cioè io la funzione stampa la vedo come un cicli o infinito. La funzione inizia a scendere con le posizioni, finchè non arriva a 0. Ma una volta arrivata a zero, interviene il return. Quel return non mi fa ricominciare da capo la funzione?

[valia]

no ritorni al chiamante e riprendi dall'esatto punto in cui ti eri fermato con contesto che avevi nell'istante della pausa

[stestisa]

Originariamente inviato da valia
no ritorni al chiamante e riprendi dall'esatto punto in cui ti eri fermato con contesto che avevi nell'istante della pausa

Ma chi gli dice poi di andare dalla posizione 0 a 2? è questo che non capisco.

[valia]

quanto ne sai di programmazione?

[stestisa]

Originariamente inviato da valia
quanto ne sai di programmazione?

Sono al primo anno di Informatica a Trento. Ho fatto 3 anni alle superiori di programmazione, ma con Pascal, C# e un po' di Delphi.

[valia]

e nessuno ti ha mai spiegato come è mappato un programma in memoria e cosa succede quando chiami una funzione?