Newsgroup: it.comp.lang.c
Titolo: Dimensione di un'area allocata

ciao a tutti...ho un quesito da porvi...è possibile determinare la
dimensione di un area precedentemente allocata tramite malloc? ad esempio io
definisco un puntatore ad un'area allocata con malloc, poi chiamo una
funzione e gli passo il puntatore, può in qualche modo tale funzione
ricavare la dimensione dell'area allocata senza che gliela passo io come
ulteriore parametro? grazie!
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

 dimensione di un area precedentemente allocata tramite malloc? ad esempio io
Purtroppo non e' possibile in maniera portabile: ogni implementazione
utilizza un algoritmo diverso per implementare la funzione malloc
e nello standard (stranamente!) non e' prevista una funzione che ti
dia questa informazione.
BTW, la tua domanda e' una FAQ: puoi vedere la risposta alla tua domanda
e ad altre su malloc al sito:
http://www.andrea.sosio.it/faqclcit.html#Allocazione
(la tua domanda e' la 7.27)
ciao
Giacomo

 ha scritto:

grazie anche per il sito, sorry non l'avevo guardato :P


vorrei porvi altri due quesiti legati in qualche modo alla dimensione di
aree allocate dinamicamente:
1)devo aprire un file su disco, copiarlo in un'area di memoria ed effettuare
delle elaborazioni. Pensavo di utilizzare la funzione fopen col percorso del
file per aprirlo e successivamente di copiare il file in un'area di memoria
tramite la funzione fread. Il mio problema è determinare la dimensione del
file e quindi dell'area che devo allocare tramite la malloc: in che modo
posso determinare quanto è grande il file su cui devo lavorare?
2)supponiamo di avere un vettore che contiene dei puntatori ad aree di
memoria allocate dinamicamente. Voglio determinare la dimensione di tale
vettore quindi pensavo di fare sizeof(vettore)/sizeof(primo elemento del
vettore) e in effetti ottengo il giusto numero di campi. In realtà questa
operazione deve essere eseguita non nel main (anche perchè l'ho dichiarato
io il vettore, quindi ne conosco le dimensioni) ma da una funzione a cui
passo il vettore di puntatori. Per quale motivo però il risultato che
ottengo è errato? Vi riporto alcune righe di codice:
int main(int argc, char** argv)
{
char *punc_word[16], buffer_dati;
int dimensione;
...
//il vettore viene riempito con puntatori di tipo char ad aree di memoria
allocate dinam
//se faccio:
dimensione=sizeof(punc_word)/sizeof(punc_word[0]);
//ottengo il valore corretto 16, se però
buffer_dati=buffer(punct_word,...,...);
}
//e all'interno della funzione buffer:
char *buffer(char *data_ptr[ ],...,...){
int dimensione;
dimensione=sizeof(data_ptr)/sizeof(data_ptr[0]); //ottengo un valore errato
e diverso dal precedente
}
grazie dell'aiuto


 errato e diverso dal precedente
Nel caso degli argomenti di una funzione, le forme
       T arg[N]
       T arg[]
sono perfettamente equivalenti a
       T* arg
Si tratta di tre modi diversi per indicare lo stesso tipo di dato, cioč un
puntatore. In tutti e tre i casi, all'interno della funzione, sizeof(arg)
coincide con sizeof(T*).
Questo vale per gli argomenti di una funzione. Negli altri casi, scrivere
         T var[ 10 ] 
č cosa ben diversa da scrivere
         T* var;
La prima espressione dichiara un array, la seconda un puntatore.
Max

 }
La ragione è che in realtà lavori su un puntatore.
Lo standard (C90) dice a proposito di sizeof:
When  applied  to  an  operand  that  has  array  type,  the
result  is  the  total  number  of  bytes  in  the  array (43)
(43)  When  applyed  to  a  parameter  declared  to  have 
array  or  function  type,  the  sizeof  operator  yields  the
size  of  the pointer  obtained  by  converting  as in 
6.2.2.1;  see 6.7.1
6.2.2.1
[...]Except  when  it  is  the  operand  of  the  sizeof 
operator  or  the  unary  &  operator,  or  is  a character 
string  literal  used  to  initialize  an  array  of 
character  type,  or  is  a  wide  string  literal  used to 
initialize  an  array  with  element  type  compatible  with 
wchar_t,  an  lvalue  that  has  type  "array of type" is 
converted  to  an  expression  that  has  type  "pointer  to 
type"  that  points  to  the  initial of element  of  the 
array  object  and  is  not  an  lvalue.[...]
6.7.1
[...]On  entry  to  the  function  the  value  of  each 
argument  expression  shall  be  converted  to  the  type
of  its  corresponding  parameter,  as  if  by  assignment  to 
  the  parameter.  Array  expressions  and
function  designators  as  arguments  are  converted  to 
pointers  before  the  call.  A  declaration  of  a
parameter  as  "array  of  type"  shall  be  adjusted  to 
"pointer  to  rype,"  and  a  declaration  of  a
parameter  as "function  returning  type"  shall  be adjusted 
  to  "pointer  to  function  returning  fype,"
as in  6.2.2.1.  The  resulting  parameter  type  shall  be an 
object  type.[...]
Ciao.