Newsgroup: it.comp.lang.c
Titolo: Allocare dinamicamente una matrice?

Ciao!
 Ho un problemino: chidere all'utente il numero di righe e di colonne
e allocare una matice (di dati inseriti dall'utente)...
Io avevo aggirato l'ostacolo dichiarando una matrice da 100x100 e poi
utilizzandone solo una parte ma il profe mi ha ostiato :-)
Se fosse un vettore sarebbe una cavolata, es vettore ad int:
int *vet, n;
scanf("%d", &n);
vet = (int *) malloc (n*sizeof(int));
Ma una matrice? Creo un array di puntatori a puntatori di array int?
TNX!

int *vet, n,m;
 scanf("%d", &n);    // numero di righe
scanf("%d", &m);    // numero di colonne
 vet = (int *) malloc (n*m*sizeof(int));
E per il salvataggio:
vet[riga][colonna] = valore;

 vet[riga][colonna] = valore;
Così non può funzionare. Semmai devi scrivere
vet[riga * m + colonna] = valore;
EMG

In C se il compilatore non č troppo delicato funzione benissimo.
Per quanto riguarda il cast: č dovuto a cut & paste dal post originale

Ma una matrice? Creo un array di puntatori a puntatori di array int?
Perche' un "array di puntatori a puntatori di array" ????
Hai tre possibili modi per implementare una matrice di interi :
1)  int **matrice ;
2)  int *matrice[N] ;
3)  int matrice [N][M] ;
Dove N e M sono due costanti definite come, per esempio :
#define N 50
#define M 50 
Dati n (numero di righe) e m (numero di colonne) forniti dall'utente
(con n <= N ed m <= M), nel primo caso l'allocazione va compiuta come
:
matrice = malloc ( n * sizeof ( int * ) ) ;
for ( i = 0 ; i < n ; i++ ) 
    matrice [i] = malloc ( m * sizeof ( int ) ) ;
Nel secondo caso :
for ( i = 0 ; i < n ; i++ ) 
    matrice [i] = malloc ( m * sizeof ( int ) ) ;
Nel terzo non viene eseguita in quanto una dichiarazione del genere
riserva gia' la memoria necessaria per la matrice.
Tratto dalle FAQ del gruppo :
6.16
----
D:	In che modo si puo' allocare un vettore multidimensionale ?
R:	La  soluzione  classica e' quella di allocare un vettore  di
  	puntatori  e  quindi  inizializzare ogni  puntatore  ad  una
  	"riga" allocata dinamicamente.
  	Un esempio per un vettore bidimensionale e' il seguente :
	#include <stdlib.h>
	int **vettore1 = malloc(nrighe * sizeof(int *)) ;
	for(i = 0; i < nrighe; i++)
           vettore1[i] = malloc(ncolonne * sizeof(int));
  	In   un' applicazione   reale,   ovviamente,   ogni   valore
  	restituito da malloc deve essere controllato.
  	Si  puo'  mantenere  contiguo  il  contenuto  del   vettore,
  	facendo   attenzione  a  "riallocare"  le   singole   righe,
  	successivamente, sfruttando l'aritmetica sui puntatori :
	int **vettore2 = malloc(nrighe * sizeof(int *));
	vettore2[0] = malloc(nrighe * ncolonne * sizeof(int));
	for(i = 1; i < nrighe; i++)
	   vettore2[i] = vettore2[0] + i * ncolonne;
  	In  entrambi i casi e' possibile accedere agli elementi  del
  	vettore dinamico usando i normali operatori [] :
	vettoreX[i][j]
  	(per 0 <= i < nrighe e 0 <= j < ncolonne ).
  	Nel  caso in cui il tipo di indirizzamento doppio  implicato
  	da  una  gestione  del  genere dei  vettori  si  presentasse
  	inaccettabile  per  qualsiasi ragione, si puo'  simulare  un
  	vettore   bidimensionale  con  uno   monodimensionale,   nel
  	seguente modo :
  	int *vettore3 = malloc(nrighe * ncolonne * sizeof(int));
  	Tuttavia,  in questo caso, bisogna calcolare manualmente  la
  	posizione dell'elemento (i, j) come :
	vettore3[i * ncolonne + j]
  	Una macro del genere :
  	#define VETTORE3 (i, j, ncol) vettore3 [i * ncol + j]
  	risulterebbe  utile, in questo caso, ma la notazione con cui
  	essa  viene invocata e' differente da quella di  un  vettore
  	bidimensionale  e  necessita  di almeno una  dimensione  (v.
  	6.19).
  	Un'ulteriore  possibile  opzione  e'  quella  di  usare  i
  	puntatori a vettori :
 	int (*vett4)[NCOLONNE] = malloc(nrighe * sizeof(*vett4));
  	Ma  la  sintassi, oltre a risultare orribile, necessita  che
  	una dimensione venga specificata a tempo di run-time.
  	Utilizzando  le  tecniche di allocazione  dinamica,  bisogna
  	ovviamente  ricordarsi di liberare tutta la memoria occupata
  	per i vettori (il che puo' richiedere piu' passi ; v.  7.23)
  	quando  essi  non  siano piu' necessari e non  e'  possibile
  	intercambiare   la  notazione  utilizzata  per   i   vettori
  	dinamici con quella utilizzata per i vettori statici.
  	(v. 6.18, 6.20)
  	Con  il  nuovo  standard C9X si potranno usare i  vettori  a
  	lunghezza variabile (VLA).
  	Tutte  le  tecniche viste finora possono essere  estese  per
  	trattare vettori a tre o piu' dimensioni.
  	Riferimenti :
  	C9X Sec. 6.5.5.2.

In C se il compilatore non è troppo delicato funzione benissimo.
Ti sbagli.
Se allochi una matrice in questo modo :
int *vett = malloc ( n * m * sizeof ( int ) ) ;
NON PUOI accedere agli elementi con
vett[i][j] 
( dove 0 <= i <= n, 0 <= j <= m )
Ma devi calcolare la posizione con 
vett[i * n + j]
Come ha giustamente segnalato EMG.