[C] array bidimensionali tramite puntatori

[filips]

Salve, ho letto questo codice e secondo me contiene almeno un paio di errori:

int main() {
 int **m;
 int i,j;
 int m,n;
 printf ("Numero di righe della matrice: ");
 scanf ("%d",&m);
 printf ("Numero di colonne della matrice: ");
 scanf ("%d",&n);
 m = (int**) malloc(m*n*sizeof(int));
 // Inizializzo anche tutti i sotto-vettori,
 // ovvero le righe della matrice
 for (i=0; i<m; i++)
 m[i] = (int*) malloc(n*sizeof(int));
 for (i=0; i<m; i++)
 for (j=0; j<n; j++) {
 printf ("Elemento [%d][%d]: ",i+1,j+1);
 scanf ("%d",&v[i][j]);
 }

Qualcuno esperto può dirmi se vede gli stessi errori che vedo io, oppure se sono io a ignorare qualche particolare che li giustifica?

[Scara95]

Due errori nella prima riga di allocazione, non ne vedo altri, a meno che non mi siano sfuggiti.

[YuYevon]

Qualcuno esperto può dirmi se vede gli stessi errori che vedo io, oppure se sono io a ignorare qualche particolare che li giustifica?

Comincia a segnalare gli errori che vedi tu.

[oregon]

In effetti, devi rivedere questa linea

m =(int**) malloc(m*n*sizeof(int));

[filips]

Non li avevo segnalati per lasciare indipendenza.

Credo errato:

m = (int**) malloc(m*n*sizeof(int));    (1)

Intanto mi sembrava ci fosse ambiguità tra le due variabili 'm'. Però questo non lo vedevo molto probabile perché ritenevo che forse il compilatore riuscisse a dedurre il tipo per la variabile in conflitto di nome, e tuttavia più sotto l'array viene denotato con 'v'. Giusto o sbagliato?

Inoltre pensavo (e qui sembrava molto probabile) dovesse essere

v = (int**) malloc(m*sizeof(int*));  (2)

visto che questa istruzione restituisce un puntatore a puntatore (m puntatori a int), e con le successive malloc sulle m righe viene completata allocando i corrispondenti m puntatori a int:

v[i] = (int*) malloc(n*sizeof(int));  (3)

Il fatto che in (2) ci fosse int anziché int*, ripensandoci, credo non si possa considerare esattamente errore visto che int e int* dovrebbero coincidere nella dimensione (4 byte su macchina a 32 bit), quindi il risultato della malloc dovrebbe essere equivalente nei due casi, almeno su una macchina a 32 bit..

[oregon]

La (2) è corretta

[filips]

@Oregon: grazie!

[YuYevon]

Un'allocazione come la (1), al di là dell'errore nell'uso della variabile m, può andare bene se la matrice viene gestita di fatto con un'array monodimensionale

#include <stdlib.h>

#define NROWS   3
#define NCOLS   5

int main(void)
{
    int *v;
    int i, j;
    
    v = (int *) malloc(NROWS*NCOLS*sizeof(int));
    if (!v) {
        return -1;
    }
    
    for (i = 0; i < NROWS; i++) {
        for (j = 0; j < NCOLS; j++) {
            *(v + i*NCOLS + j) = 0;
        }
    }

    free(v);
    return 0;
}

in quanto a questo

Il fatto che in (2) ci fosse int anziché int*, ripensandoci, credo non si possa considerare esattamente errore visto che int e int* dovrebbero coincidere nella dimensione (4 byte su macchina a 32 bit), quindi il risultato della malloc dovrebbe essere equivalente nei due casi, almeno su una macchina a 32 bit..

come avrai intuito, non bisogna fare mai assunzioni sulla dimensione dei tipi di dato relativi all'architettura, quindi quello di fatto è proprio un errore. Che un int sia rappresentato con 4 byte su un sistema a 32 bit può essere un'utile "rule of thumb", ma non hai garanzia generale che sia così.

[filips]

@Yuyevon, interessante la precisazione sulla matrice come array mono. In effetti (v + i*NCOLS + j) è proprio la formula per ottenere il dato alla riga i+1 esima e colonna j+1esima. Ti ringrazio anche per la precisazione sul fatto che in generale non è saggio affidarsi a ipotesi architetturali particolari. Ottima risposta