[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? :muro:

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.