Newsgroup: it.comp.lang.c
Titolo: Matrice di dimensione variabile.

Se una matrice di interi 2x3 si scrive: "int a[2][3]" come si scrive una
matrice di dimensioni variabili x,y?
Grazie in anticipo.
Uno GNorante.
ant...@sorrento.argosid.it

matrice di dimensioni variabili x,y?
Non si scrive; non e` parte del linguaggio Standard C.
Tali matrici si simulano in uno di due modi:
    -- array di array (piu` simile alle matrici come notazione), o
    -- array monodimensionali con aritmetica di indici (migliori
        prestazioni, notazione piu` scomoda).
Alex


Non la si scrive, perche' il compilatore non sa quanto grande e'.
Occorre allocarla dinamicamente.
int **ppInt;
int i;
ppInt =(int **)malloc(x*sizeof(int));
for (i=0;i<x;i++){
    ppInt[i]=(int *)malloc(y*sizeof(int));
}
ppInt[5][7]=0xFFFFAA55;
e deallocarla nello stesso modo (cioe' al contrario).







 e deallocarla nello stesso modo (cioe' al contrario).
Per una discussione approfondita dell'allocazione dinamica di matrici, e'
meglio guardare a 
http://www.eskimo.com/~scs/C-faq/top.html
Ciao Paolo
-----------== Posted via Deja News, The Discussion Network ==----------
http://www.dejanews.com/
       Search, Read, Discuss, or Start Your Own    

Brugiolo Ivan (
iv...@nospam.iperv.it
) wrote:
[ snip ]
: int **ppInt;
: int i;
: ppInt =(int **)malloc(x*sizeof(int));
                                ^^^^^
Qui va "sizeof(int *)".
: for (i=0;i<x;i++){
:     ppInt[i]=(int *)malloc(y*sizeof(int));
: }
Ciao ciao
Andrea
-- 
"...Unix, MS-DOS, and Windows NT (also known as the Good, the Bad, and 
 the Ugly)."
(by Matt Welsh)

> ppInt =(int **)malloc(x*sizeof(int));


Perche' potenzialmente dannoso?
Presumibilmente l'osservazione si riferisce a una riga del tipo:
    int **ppi = (int**)malloc(n*sizeof(int*));
Questa sarebbe necessaria per chi volesse usare malloc in C++
per qualche misteriosa ragione (new int*[n] sarebbe ovviamente
meglio in quel caso).  In C, invece, il void* tornato da malloc si
trasforma automaticamente in qualsiasi puntatore richiesto.
Ma supponiamo che uno si sia scordato di dichiarare malloc (in
pratica, di mettere un necessario #include).  In C++, questo
sarebbe comunque un errore; ma in C, no -- il compilatore e`
tenuto (si spera con un warning, ma non e` obbligatorio) a
compilare lo stesso il codice, interpretando malloc come una
funzione che torna un int.  Ora, senza il cast:
    int **ppi = malloc(ecc)
da` comunque errore (assegnazione di int a puntatore) e quindi
il disastro viene evitato; ma il cast obbliga invece il compilatore
a produrre codice -- disastro.
Il disastro verra` mascherato sulle architetture per cui int e
void* usano lo stesso numero di bit, probabilmente (cioe`
nell'ipotesi che una funzione che torna int, e una che torna
un puntatore, mettano il risultato nello stesso registro o che);
ma su di un Alpha, ad esempio, con puntatori a 64 bit e int
a 32 bit, questa situazione "affettera`" la meta` superiore
del puntatore; provocando, magari, una funzione che gira
tranquillamente in piccole situazioni di test, cioe` sinche`
la memoria allocata sta entro i primi 4giga dello spazio di
indirizzi virtuali, e si mette a pazziare solo in situazioni reali
di produzione, quando gli indirizzi tornati da malloc iniziano
a "debordare" dai primi 4 giga... difficile pensare un caso
piu` rognoso da debuggare di questo!
Se si deve a tutti i costi programmare in C, senza gli aiuti
ulteriori che il C++ offre per il controllo dei propri programmi,
e` meglio dunque evitare questo rischio, e obbligarsi a non
castare i risultati delle malloc().
Alex