Newsgroup: it.comp.lang.c
Titolo: Problema con allocazione dinamica...

Salve a tutti.
Sono fresca fresca sia del newsgroup che del C...ed avrei bisogno di un
aiutino, non essendo stata capace di trovare qualcosa di chiaro con
google...
Il problema č:
se per allocare dinamicamente un array monodimensionale faccio:
int *array
int n
array=(int*) malloc (n * sizeof(int))
.........
come diavolo faccio per un array 2D ?
Aiutatemi pls ! Ho provato in mille modi ma non mi funziona un tubo! :(

 array=(int*) malloc (n * sizeof(int))
OK ci provo! :-)
int *array[10];
array= (int*)malloc(n * sizeof(int));
E' chiaro che la dimensione del primo array la devi definire.
Non sň se č proprio quello che cercavi! :-)
Spero di esserti stato utile.
Ciao
Paolo

 Non sò se è proprio quello che cercavi! :-)


 come diavolo faccio per un array 2D ?
Dipende da  come vuoi  gestire l'array. Lo  standard garantisce  che gli
elementi di  un array  bidi statico siano  contigui. Se ti  serve questa
garanzia allora devi allocare la matrice in un colpo solo:
struct matrix {
        int rows;
        int cols;
        int *data;
}
struct matrix *alloc_matrix(int r, int c) {
        struct matrix *ret;
        ret = malloc(sizeof(*ret));
        if (!ret)
                return NULL;
        ret->data = malloc(r * c * sizeof(int));
        if (!ret->data) {
                free(ret);
                return NULL;
        }
        ret->cols = r;
        ret->rows = c;
        return ret;
}
int matrix_get(struct matrix *m, int r, int c) {
        if (r >= m->rows || c >= m->cols)
                /* Hum */
                return -1;
        return ret->data[r * m->cols + c];
}
void matrix_set(struct matrix *m, int r, int c, int val) {
        if (r >= m->rows || c >= m->cols)
                return;
        ret->data[r * m->cols + c] = val;
}
void release_matrix(struct matrix *m) {
        free(m->data);
        free(m);
}
Altrimenti:
int **matrix;
matrix = malloc(rows * sizeof(int *));
if (!matrix)
        ....
for (i = 0; i < rows; i++) {
        matrix[i] = malloc(cols * sizeof(int));
        if (!matrix[i])
                cleanup();
}
HTH,
Luca
-- 
Home: 
http://kronoz.cjb.net
E' stato a causa di una donna che ho cominciato a bere e non ho mai
avuto la cortesia di ringraziarla.

 wrote
alloca una sola dimensione alla volta...
nell'esempio che segue creo una cosa simile a "int p[40][25]" ma
dinamicamente.
uso "int **p;", poi con calloc alloco 40 puntatori inizializzati a NULL.
poi con un ciclo per ogni puntatore alloco 25 elmenenit e con un ciclo
inizializzo questi con un numero (non importante) che in questo caso e' "i +
ii".
<CODE>
#include<stdio.h>
#include<stdlib.h>
int main()
{
     int **p = NULL;
     int i = 0;
     int ii = 0;
     // alloco prima dimensione, 40 elementi!
     p = calloc(40,sizeof(int*));
     // ora per ogni puntatore (ne ho 40) alloco 25 elementi
     for(i=0; i<40; ++i){
          p[i] = malloc(25*sizeof(int));
          // inizializziamo ogni elemento:
          for(ii=0; ii<25; ++ii){
               p[i][ii] = i + ii;
          }
     }
     // fatto! stampiamone un paio:
     printf("%d - %d\n",p[8][7], p[38][22]);
     return 0;
}
</CODE>
in pratica il programma stampa:  15 - 60
(8+7) - (38+22)
NB: devi anche deallocare la memoria (per pigrizia in questo esempio non ho
fatto).
NB: evita nomi stupidi come i e ii, si possono confondere! Li ho usati solo
per masochismo (o quasi) ;-)
NB: il cast prima della malloc in C non serve! Se usi un compilatore C++ ti
serve e... sono rispettivamente: (int**) e poi (int*). Tuttavia se usi il
C++ ti conviene evitare malloc ;-)
Tommy

 array= (int*)malloc(n * sizeof(int));
neanche lo compila questo.
Come già detto da luca, via il cast da malloc e usa un puntatore doppio:
int ** array
a questo punto allochi la "prima dimensione"
array = malloc( 10 * sizeof( int* ));
e poi "la seconda"
for( i = 0; i < 10; i++ )
	array[i] = malloc( 10 * sizeof( int ));
Ciao
Matic

Grazie a tutti...
mi siete stati di grande aiuto :))