Scorrimento matrice ricorsione C

[abaco90]

Ciao a tutti,

sto cercando di scrivere una funzione che scorre una matrice e ritorna 1 quando trova il numero 8.

Questo è il mio codice:

#define DIM 4

int scorrimatrice(int matrice[DIM][DIM], int r, int c, int dimensione) {

	if (matrice[r][c] == 8) {

		return 1;
	}

	else if (c == dimensione) {

		return scorrimatrice(matrice, r++, 0, dimensione);
	}

	else return scorrimatrice(matrice, r, c++, dimensione);
}

int main () {

	int matrice[DIM][DIM] = {

		{1, 0, 0, 2},
		{0, 0, 7, 0},
		{0, 1, 9, 0},
		{2, 0, 1, 8}
	};

	printf("%d\n", scorrimatrice(matrice, 0, 0, 4));

	return 0;
}

ma continua a darmi segmentation fault. Credo di essere vicino alla soluzione, ma non capisco dove sbaglio.

Qual è l'errore?

Grazie!

[vict85]

Devi fare il test con [inline]dimensione-1[/inline] e non con [inline]dimensione[/inline]. Inoltre non stai gestendo il caso in cui non trovi alcun 8 nella matrice.

[Super Squirrel]

In realtà ci sono varie cose che non vanno:
- c++ ritorna il valore di c prima dell'incremento, quindi la ricorsione avviene continuamente con valori di r e c pari a 0. Al posto di c++ avresti dovuto usare ++c o ancora meglio un semplice c+1 (lo stesso discorso vale anche per r);
- ipotizziamo di entrare nella funzione con r=0 e c=3 (in pratica stiamo analizzando la prima riga). Stando al codice verrà invocata nuovamente la funzione con r=0 e c=4, ma l'elemento matrice[0][4] non fa parte della matrice. La condizione andrebbe quindi corretta in c==dimensione-1;
- ipotizziamo che non ci siano 8 e di entrare nella funzione con r=3 e c=3. Stando al codice verrà invocata nuovamente la funzione con r=4 e c=0, ma siamo chiaramente al di fuori della matrice. Non essendoci inoltre alcun controllo su r, tale variabile sarà incrementata continuamente;
- ipotizzando che non ci siano 8, che valore ti aspetti che ritorni la funzione? Bisogna quindi aggiungere un return 0 (o qualsiasi altro valore) alla fine della funzione.

Io farei qualcosa del genere:

#include<stdio.h>
#include<stdlib.h>

#define DIM 4

int scorrimatrice(int matrice[DIM][DIM], int r, int c)
{
    if(matrice[r][c] == 8)
    {
        return 1;
    }
    else if(c != DIM - 1)
    {
        return scorrimatrice(matrice, r, c + 1);
    }
    else if(r != DIM - 1)
    {
        return scorrimatrice(matrice, r + 1, 0);
    }
    return 0;
}

int main()
{
    int matrice[DIM][DIM] = {{1, 0, 0, 2},
                             {0, 6, 7, 0},
                             {6, 1, 9, 0},
                             {2, 0, 1, 8}};
    printf("%d", scorrimatrice(matrice, 0, 0));
    return 0;
}

[abaco90]

Vi ringrazio entrambi per le risposte!

Ho provato a sostituire r++ con r + 1 e c++ con c + 1, lasciando invariato il resto del codice e funziona.
In realtà non ho scritto il caso in cui non trovo nessun 8 in quanto era solo un test per provare la ricorsione sulle matrici.

Non ho ancora capito però come mai scrivendo + 1 invece che ++ funziona. Non hanno lo stesso significato?

[Super Squirrel]

OK che è una prova e non hai gestito il caso di 8 assente, ma come evidenziato al punto 2 del mio precedente post, stai analizzando zone di memoria che non competono alla matrice, quindi oltre al ++ qualche aggiustamento andrebbe apportato.

Per quanto riguarda l'operatore di incremento ++, esso può essere sia prefisso che postfisso e ovviamente agiscono in modo diverso:
- quello prefisso (++n), incrementa n e ritorna il valore incrementato;
- quello postfisso (n++), incrementa n, ma ritorna il valore non incrementato.
Per rendertene conto, una volta dichiarata e inizializzata una variabile intera n, prova a stampare in sequenza ++n e n e poi n++ e n.

[abaco90]

Ho capito, sei stato molto chiaro, grazie mille!