Newsgroup: it.comp.lang.c
Titolo: Allocazione dinamica bidimensionale

Salve,
mi sapreste dire come creare un array bidimensionale di interi?
Per creare un array a una dimensione faccio:
int *p;
p=(int*)malloc(10*sizeof(int));
Fin quì tutto ok...
adesso però ne vorrei fare uno del tipo int p[10][20] però decidendo le
dimensioni dinamicamente...
Mi aiutate??
Grazie
xoooox
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

 Mi aiutate??
Che io sappia, l'unica soluzione e' quella del 'jagged array':
int i;
int **p;
p = malloc(10*sizeof(int*));
for(i = 0; i < 20; i++)
   p[i] = malloc(20*sizeof(int));
Semanticamente, non hai per niente lo stesso risultato di un int 
p[10][20], pero' all'atto pratico, l'utilizzo e' identico; ad es:
p[3][5] = 4;
e' legale, e fa quello che ti aspetti.
-- 
Mat/tia Belletti - Undergraduate student @ 
cs.unibo.it
ICQ: 33292311    - email: 
mbel...@cs.unibo.it
IRC: RedGlow     - site(s): 
http://www.cs.unibo.it/~mbellett
Linux registered user 299762 @ Linux registered machine 213003

 ha
scritto:

Ok... mi funziona :)
però nel for ho messo 10 anzicchè 20... non mi spiego quel venti se hai
creato un array di 10..
per il resto tutto ok....
Cortesemente mi potresti indicare dove leggere la faq... per il cast che ho
fatto al malloc...
così mi imparo un'altra cosa :)
Comunque grazie :)
ciao


 fatto al malloc...
Mattia faveva riferimento alla FAQ di comp.lang.c (e cmq e` una domanda
ricorrente sul ng, cerca anche negli archivi di google):
www.eskimo.com/~scs/C-faq/top.html
In particolare:
http://www.eskimo.com/~scs/C-faq/q7.6.html
http://www.eskimo.com/~scs/C-faq/q7.7.html
Luca
-- 
Home: 
http://kronoz.cjb.net
Windows NT: Designed for the Internet. The Internet: Designed for Unix.

 ha
scritto:

Ciao,
mi dici che non bisogna usare un cast in malloc però se uso questa linea di
codice:
p = malloc(10*sizeof(int*));
mi dà un errore... "Non si può convertire Void* in int**"
Invece se uso il cast:
p=(int**)malloc(10*sizeof(int*));
Mi compila bene.
Come dovrei fare ?
Un'altra cosa...
Dopo che ho creato un array bidimensionale lo azzero (=0 ogni valore) con un
due cicli for
e poi gli assegno i valori che mi servono... certe volte non mi esce quello
che mi aspetto. Se ripeto la funzione per una decina di volte almeno una
volta su 10 i valori nell'array me li trovo sballati. (sono interi
dell'ordine da 1 a 10).
Può centrare per caso il cast della malloc?
al termi ne della funzione ho messo:
free(p);
Va bene scritto cosi?
Scusami se ti pongo 100 quesiti.... :)
Cmq Grazie ancora per le risposte :)
Ciao


 Va bene scritto cosi?
No, per la semplice regola aurea del: "ad ogni malloc, una ed una sola 
free". Se tu fai n+1 malloc, dovrai fare n+1 free, non 1 free come hai 
scritto tu.
Saluti!



 


 Però me lo dà come Error e non come warning... cmq... va bene :)
Si`, in C++ non e` proprio legale la conversione tra due puntatori
diversi. Btw, esiste un flag per dire al compilatore di usare la
modalita` C (oltre ad usare .c come estensione dei file); non la ricordo
ma prova a cercare nella documentazione.
Luca
-- 
Home: 
http://kronoz.cjb.net
Software is like sex; it's better when it's free.
Linus Torvalds


Prendi _esattamente_ il codice delle malloc, inverti l'ordine (prima era 
malloc + for di malloc, ora metti prima il for), e trasformi le malloc 
in free.
Questa evidenzia l'esatta simmetria di free e malloc :)
