[C] Aritmetica dei puntatori con le matrici

[ghoan86]

Salve a tutti,
volevo sottoporvi un problema riguardante l'utilizzo dell'aritmetica dei puntatori relativo alle matrici in C.
In pratica il mio problema è il seguente: data una matrice N*N i cui elementi sono ad esempio dei float, sfruttando la caratteristica del C di memorizzare in maniera contigua le righe di una matrice, voglio stampare a video la matrice utilizzando un unico ciclo for e l'aritmetica dei puntatori anzichè utilizzare il doppio ciclo for e la notazione matrix[i][j].

Vi riporto il codice :

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

#define _DIMMATRIX 4

int main (int argc, char *argv[])
{

	float **matrix; // matrice 
	
	// allocazione dinamica della matrice 
        matrix=(float **)malloc(_DIMMATRIX*sizeof(float *)); // alloco il vettore delle righe, ogni elemento dei questo vettore e' un puntatore
	
	float offset=0;
	int i,j;
	for(i=0; i<_DIMMATRIX; i++) { // per ogni riga alloco le colonne
            matrix[i]=(float *)malloc(_DIMMATRIX*sizeof(float));
	for(j=0; j<_DIMMATRIX; j++){ // inizializzo la matrice 
                matrix[i][j]= offset;
		offset++;		
		}

        }
    
        //Stampa a video
	int t;
	for (t=0; t < (_DIMMATRIX * _DIMMATRIX); t++) {

		printf("%f\t", *(&matrix[0][0] + t ) );
        	printf("\n");
		}
         //deallocazione matrice 
	for(i=0; i<_DIMMATRIX; i++) // dealloco prima le colonne
            free(matrix[i]);

        free(matrix); // dealloco il vettore delle righe


	return 0;
}

So che il codice risulterà banalissimo ma il risultato che esce fuori per (N=4) è il seguente:

0.000000	
1.000000	
2.000000	
3.000000	
0.000000	
0.000000	
4.000000	
5.000000	
6.000000	
7.000000	
0.000000	
0.000000	
8.000000	
9.000000	
10.000000	
11.000000

Perché invece allocando staticamente la matrice il risultato risulta essere corretto?

Sperando di essere stato chiaro, ringrazio in anticipo tutti coloro che vorranno darmi una mano .

PS: Ovviamente per agevolare la comprensione del problema ho usato dei valori interi, il problema richiede di utilizzare i float.

[Cait Sith]

Se vuoi tutti gli elementi contigui fai così:

float **R;
int Nrighe;
int Ncolonne;
R = (float **)calloc(Nrighe, sizeof (float *));
R[0] = (float *)calloc(Ncolonne * Nrighe , sizeof (float));
for (k = 1; k < Nrighe; k++) {
    R[k] = R[0] + k * Ncolonne;
}

In pratica allochi tutti gli elementi in una volta e li associ al primo elemento dell'array di puntatori, poi gli altri elementi li costruisci in base al primo saltando di Ncolonne elementi.
Per disallocare basta fare (senza bisogno di cicli):

free(R[0]);
free(R);

Il vantaggio è che (volendo) puoi usare una indicizzazione uno 1D, che è più efficiente, facendo:

float *R1D;
R1D=R[0];
for(r=0;r<Nrighe;r++){
   for(c=0;c<Ncolonne;c++){
      R1D[r*Ncolonne+c]=1.0;
   }
}

E' utile anche se devi fare un memset o un memcpy, che a questo punto faresti una volta sola su tutta la matrice anzichè riga per riga.

[ghoan86]

Si Cait Sith effettivamente l'errore che facevo era che dichiarando la matrice come vettore di puntatori a vettore, l'allocazione avveniva sull'heap in blocchi non contigui. Effettivamente la seconda soluzione mi permette di evitare l'allocazione di ulteriori puntatori , visto che posso ottenere lo stesso risultato con un vettore di 1D.

Ti ringrazio!!

Antonio23
non credo sia standardizzato da nessuna parte che le righe devono essere allocate contiguamente... quindi quando l'allochi staticamente nello stack sei fortunato, quando invece l'allochi dinamicamente nell'heap...no

Ringrazio anche te Antonio23, ma comunque in tutti i libri di C c'è scritto che la memorizzazione di una matrice avviene per righe in modo contiguo, infatti se ho capito bene allocando staticamente sullo stack, viene riservato un blocco contiguo per tutti gli elementi della matrice.