Newsgroup: it.comp.lang.c
Titolo: Dimensione variabile

Come si fa a sapere la reale dimensione della memoria allocata per una
variabile?
In teoria l'operatore sizeof dovrebbe fare al caso mio, no?
Ma come faccio nel caso di un puntatore a carattere? Mi ritorna sempre 4
bytes, qualsiasi sia la dimensione della stringa. Perchè?

Fabbro wrote:

sizeof(ptr); da la dimensione del puntatore.
sizeof(*ptr); da la dimensione del tipo puntato.
Non esiste la possibilità di avere la dimensione di un blocco di memoria 
allocato dinamicamente.

 bytes, qualsiasi sia la dimensione della stringa. Perchè?
L'operatore sizeof restituisce il numero di byte occupati dal contenuto di
una variabile.  Un puntatore è appunto una variabile, il cui contenuto è
un indirizzo.  Quindi sizeof, applicato ad un puntatore, restituisce il
numero di byte occupati dal contenuto del puntatore, ovvero il numero di
byte occupati da un indirizzo.  Su una macchina con indirizzi a 32 bit
come la tua, sizeof restituisce 4, perché un puntatore "occupa", appunto 4
byte.
Se vuoi sapere la lunghezza di una stringa, devi usare la funzione
strlen() string.h) che non fa altro che scorrere la memoria puntata dal
puntatore a caratteri, contare tutti i caratteri che incontra fino al
terminatore nullo (escluso) e restiture questo valore.
Stai attento al caso seguente:
    char a[] = "pippo";
    size_t size_of_a = sizeof a;
In questo caso size_of_a avrà valore 6, ovvero il numero di caratteri che
formano l'array, più il terminatore nullo.  Questo caso è una delle tre
eccezioni in cui un array _non_ decade in puntatore al primo elemento.  
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 terminatore nullo (escluso) e restiture questo valore.
Il problema di questo approccio è che non sto lavorando con stringe
"human-readable": sono sequenze "incasinate" di bit provenienti da una
cifratura mediante RSA. Strlen restituisce la lunghezza della stringa
finchè non trova il terminatore 0, che (sulla mia macchina) corrisponde ad
una sequenza di 8 bit 0. E purtroppo nulla vieta ad RSA di inserire 8 zeri
in una stringa da lui creata. Perciò, anche se la stringa cifrata in
qeustione è lunga 200 bytes, magari contiene 8 zeri al byte 17 il che fa
ritornare a strlen esattamente 17. 
Spero di essere stato chiaro.
Comunque grazie dell'intervento.

 ritornare a strlen esattamente 17. 
Ok, ma in questo caso non c'è soluzione.  Se tu hai un puntatore a
caratteri, la cui memoria puntata è di una certa dimensione, perché tu
possa accedere a tutti e soli i caratteri, devi conoscere a priori la
dimensione.  Non c'è funzione, in questo caso, che tenga.


 dimensione.  Non c'è funzione, in questo caso, che tenga.
Comunque mi pare che gli algoritmi di crittografia in genere conoscono a 
priori la dimensione dei buffer usati.
Oddio, potrebbero cambiare magari in base alla lunghezza del dato da 
criptare o della chiave in utilizzo, o al fatto che l'algoritmo esista 
in più versioni (vedi SHA-1 e i suoi fratelli), ma in ogni caso si sa 
comunque quanto è grande il buffer in uso...
Quindi...
-- 
Quando noi ignoranti eravamo di più, tutto era più bello (A. Celentano).
  ___   _   ___ _  _______   _______ ___
|   \ /_\ | _ \ |/ / _ ) \ / /_   _| __|
| |) / _ \|   / ' <| _ \\ V /  | | | _|
|___/_/ \_\_|_\_|\_\___/ |_|   |_| |___|

 priori la dimensione dei buffer usati.
Mi sembra quantomeno ovvio.


 Mi sembra quantomeno ovvio.
Appunto, dico...
Quindi non vedo la sua necessitā di calcolare le dimensioni di quel 
buffer o_O
-- 
Quando noi ignoranti eravamo di pių, tutto era pių bello (A. Celentano).


>>priori la dimensione dei buffer usati.
In effetti in RSA la dimensione del buffer in cui si memorizza il testo
cifrato (un char*, appunto) è identica a quella della chiave di cifratura
utilizzata.
Pertanto il problema non esiste... 
Era solo mia personale curiosità sapere se era possibile conoscere la
dimensione di quel buffer, nonostante la sua formattazione "strana".
Grazie comunque.

 dimensione di quel buffer, nonostante la sua formattazione "strana".
Questo è uno dei rari casi in cui non bisogna fare confusione fra array e
puntatori. Prendi questo codice:
   char Pippo [10];
   char * Pluto = Pippo;
Siamo abituati al fatto che variabili come Pippo e Pluto si comportano
praticamente nello stesso modo in praticamente tutte le situazioni, per
cui tendiamo a considerarli la stessa cosa. In realtà non lo sono, come
vedi con questo codice:
   printf("Pippo: %d", sizeof(Pippo));
   printf("Pluto: %d", sizeof(Pluto));
La prima printf stampa 10, perché Pippo è un array di dieci char. La
secoda stampa 4 (o, comunque, la dimensione di un puntatore su quel
compilatore), perché questo è solo a un puntatore, che in questo momento
punta al primo carattere di Pippo, ma che potrebbe puntare a qualsiasi
altra cosa.
--
Cingar


 dimensione di quel buffer, nonostante la sua formattazione "strana".
No.
