Ottenere la dimensione di un malloc solo con il puntatore restituito

Voglio essere in grado di variare le dimensioni del mio array così ne creo uno in questo modo:

int* array; array = malloc(sizeof(int)*10);//10 integer elements 

Posso usare questo come un array come faresti normalmente, tuttavia quando provo a trovarne la dimensione in questo modo:

 size = sizeof(array)/sizeof(int); 

Ottengo la risposta 1 perché non lo riconosce come indicante un array

Come posso ottenere la dimensione dell’array? (So ​​che non è tecnicamente un array ma esiste un modo per calcolare l’intera dimensione del blocco di memoria assegnato?)

Inoltre ho ragione ad assumere ciò che ho affermato nella descrizione? Se sono tecnicamente sbagliato su qualcosa per favore correggimi.

Il puntatore è un puntatore e non un array. Non può mai essere “riconosciuto come un array”, perché non è un array .

Spetta interamente a te ricordare la dimensione dell’array.

Per esempio:

 struct i_must_remember_the_size { size_t len; int * arr; }; struct i_must_remember_the_size a = { 10, NULL }; a.arr = malloc(a.len * sizeof *a.arr); 

Non esiste un modo standard per fare ciò che chiedi. Alcuni compilatori possono fornire una funzione per questo, o alcuni altri allocatori possono avere tale funzione, ma, come già detto, non c’è nulla di standard.

Si noti che la dimensione applicata sugli array non funziona perché riconosce il puntatore “as from a array”: riconosce semplicemente il suo argomento come una matrice ( sizeof è uno dei pochi contesti in cui un array non decompone a un puntatore al suo primo elemento); una volta che il tuo array decadrà a un puntatore sizeof produrrà solo la dimensione del puntatore.

Innanzitutto, sizeof () restituisce la dimensione di un “tipo”; non sa nulla della memoria allocata.

Secondo, non c’è modo di ottenere la dimensione di un blocco di malloc (), A MENO CHE tu voglia scavare nella parte interna della libreria di runtime del tuo compilatore. Il che non è sicuramente una buona idea, soprattutto dal momento che non è un problema ricordare la dimensione altrove — è ansible aggiungere un prefisso al blocco di memoria con un altro elemento per archiviare le dimensioni oppure memorizzarlo separatamente.

In C standard e portatile, è imansible. Basta notare che alcuni compilatori forniscono estensioni non standard ( msize traccia, ad esempio msize ).

Inoltre, l’operatore sizeof non può dirti la dimensione del blocco, quindi restituisce la dimensione del puntatore (ricorda che sizeof opera in fase di compilazione, tranne che con matrici di lunghezza variabile).

Quindi devi mantenere la dimensione allocata, ad esempio in una struttura dati come:

 #include  typedef struct { int *p; size_t n; } array; 

Utilizza un tipo puntatore-array piuttosto che un tipo puntatore-elemento:

 int (*parray)[10] = malloc(sizeof *parray); 

Quindi sizeof *parray ti dà la risposta desiderata, ma devi accedere alla matrice usando l’operatore * , come in (*parray)[i] (o in modo equivalente, anche se confuso, parray[0][i] ). Nota che nel moderno C, 10 può essere sostituito con una variabile.