Newsgroup: it.comp.lang.c
Titolo: Tipo size_t in C

Perchï¿œ la funzione getSize ritorna 4 Byte e non 1 Byte dato che la il 
vettore array ï¿œ di tipo char?
 
Grazie
nero23
 
 
CODICE:
 
 
 
 
 
 
#include <stdio.h>
 
 
size_t getSize( char *ptr ); //prototipo di funzione
 
int main( void )
     {
     char array[]="pippo";
     printf( "%d\n", sizeof( array )); // VISUALIZZA 6
     printf( "%d\n", getSize( array )); // VISUALIZZA 4 ???
     }
 
 
size_t getSize( char *ptr )
     {
     return sizeof( ptr );
     }

      }
 
Tu vuoi sapere la le dimensioni di un puntatore a char giusto?
 
 

 Tu vuoi sapere la le dimensioni di un puntatore a char giusto?
 
Voglio sapere la dimensione della cella che contiene il dato array[0].
Ad ogni modo, ho trovato l'errore. Ho scitto ptr anzichè *ptr
 
 
 
size_t getSize( char *ptr )
     {
     return sizeof( *ptr );
     }

 
 
Viste le domande che continui a fare da un po' di tempo a questa parte, non
posso non consigliarti di prendere seriamente in considerazione di studiare
un po' le fondamenta del linguaggio, per evitare di incappare sempre negli
stessi errori!
In questo specifico caso, non solo non c'era bisogno di una funzione, non
solo bastava mettere sizeof(char) e basta, ma anche non metterlo è lo stesso,
visto che lo standard garantisce che sia sempre uguale ad 1.
 
Ciao!
 
P.S. Visto che già so l'obiezione, sizeof(char)=1 non significa che CHAR_BIT
in limits.h sia per forza uguale ad 8.

 visto che lo standard garantisce che sia sempre uguale ad 1.
 
 
conclusione affrettata da parte tua. L'esempio mi serve solo per 
verificare e ho capito la lezione che stavo studiando!!


 Prima di tutto un char non è sempre un byte. 
 
credo che sizeof char == 1 sia una delle pochissime certezze del c...
 
-- 
ZeD

 credo che sizeof char == 1 sia una delle pochissime certezze del c...
 
questo lo so...
a me interessa capire perchï¿œ la funzione non restituisce 1 dato che il 
parametro che gli viene passato punta a una cella di memoria di tipo char.
 
Nell'esempio riportato sul libro, non c'ï¿œ l'asterisco...
 
 

 Nell'esempio riportato sul libro, non c'è l'asterisco
 
Non è detto che l'esempio sul libro sia corretto o magari copiando hai 
fatto qualche errore.

 Mi sembra che il tuo esempio funzioni.
 
il mio esempio restituisce 1 ed ï¿œ ciï¿œ che mi aspettavo.
Per essere certo che la soluzione sia quella giusta, volevo la conferma 
da parte vostra.
 
 
 
 
 
size_t getSize( char *ptr )
     {
     return sizeof( *ptr );
     }

 credo che sizeof char == 1 sia una delle pochissime certezze del c...
 
Ecco la polemica. 
 
Che  sizeof (char) sia 1 (sono necessarie le parentesi) è certo come
la morte, che sia uguale ad un byte è un'altra faccenda.
 
 
 

 parametro che gli viene passato punta a una cella di memoria di tipo char.
 
Perché tu fai stampare la dimensioni del tipo puntatore a caratteri.
 
PS en passant: sul Deitel & Deitel l'esempio è diverso e la funzione 
getSize è definita così:
 
/* restituisce la dimensione di ptr */
size_t getSize( float *ptr )
{
    return  sizeof( ptr );
 
} /* fine della funzione getSize */
 
Più di cercare di rifare l'esempio nel modo corretto cerca di non
fare avverare le parole del Vangelo: guarderete e non vedrete,
leggerete e non capirete ;-)

 CODICE:
<cut>
 
La sessione di esami si avvicina insesorabilmente eh?
Ovviamente si studia sempre l'ultima settimana.
 
 

 da parte vostra.
 
Sì, confermo che è quello che ti aspettavi e mi sembra anche corretto.
Se a sizeof fornisci (char*) ti restituisce la dimensione del puntatore, 
se invece fornisci (char) ti restituisce la dimensione di un char.

 Ovviamente si studia sempre l'ultima settimana.
 
 
Purtroppo no. Studio il C solo per passione (vengo da vb...)
 
ciao

 {
 
caspita....
mi era completamente sfuggito il commento
riportato nel libro " /* restituisce la dimensione di ptr */."
 
Ora si spiega tutto
 
ciao
 
 
 


lo standard ANSI dice questo:
The sizeof operator yields the size in bytes of its operand
 
e questo:
 
When applied to an operand that has type char, unsigned char, or signed 
char, (or a qualiﬁed version thereof) the result is 1
 
quindi poichè sizeof(char) ritorna sempre 1 e poichè sizeof ritorna la 
grandezza in bytes si ha per transizione che la grandezza di un char è 
uaguale alla grandezza di un byte, sempre; sostanzialmente si dice che 
byte == char
 
Naturalmente byte non significa necessariamente 8 bit
 
Come avevo già specificato tempo fa in qualche post, il termine char in 
C è improprio, avrebbero dovuto chiamarlo byte
Un vero char ha grandezze che dipendono dalla codifica utilizzata 
(ascii,unicode,ecc..)
 
 

 sizeof (char) sia 1 (sono necessarie le parentesi)
 
no, non lo sono.
 
-- 
ZeD
 

 no, non lo sono.
 
 
L'operatore sizeof non vuole le parentesi ma quel (char) 
effettua il castingcast. Le parentesi sono necessarie.

 (ascii,unicode,ecc..)
 
Giusto quanto detto prima, però questo ha bisogno di una precisazione.
Il C è nato per programmare una particolare macchina a 16 bit in un'epoca 
dove ancora il byte poteva andare da sei a nove bit. C'era bisogno di 
distinguere dati a 16 bit e dati a 8 bit, byte avrebbe fatto confusione. 
 
Infine ricorda che vale sempre il vecchio detto che non sbaglia mai:
Se mia nonna non fosse morta sarebbe ancora viva.


  Non era certo mia intenzione accusare di negligenza gli inventori e 
che ha fatto gli standard a suo tempo
Difficile prevedere allora che char non significa necessariamente un 
byte ma la sua lunghezza in bytes dipende dalla codifica utilizzata
 
 
 

 byte ma la sua lunghezza in bytes dipende dalla codifica utilizzata
 
Più semplicemente dipende dall'implementazione del compilatore e la 
codifica utilizzata c'entra poco. Ho lavorato su un processore di segnale
che aveva un solo tipo di dato, la parola a 32 bit, ed il char era di 32 bit
 
 

 usare nibble e byte, il cui uso all'epoca non era standardizzato
 
OPS! Manca l'ultima riga. Mi scuso e completo la frase:
 
 ... la scelta naturale  fu usare "char" e "word";
 usare "nibble" e "byte", il cui uso all'epoca non era standardizzato,
o altre parole avrebbe creato solo confusione.


Dipende da come vuoi chiamare che le cose, basta intendersi.
Quello che tu chiami char per me è byte  (che puo essere di n bit non 
necessariamente 8)  e questo è stato previsto dallo standard (la 
costante CHAR_BIT è l'esempio)
Mentre il char è un carattere di una determinata codifica 
(ASCII,Unicode,UTF8,ecc..)
Il numero di byte che occupa può essere 1 o > 1 e in alcuni casi (come 
UTF8) la lunghezza in byte dipende dal carattere
Ma se chiami char il byte, il char che intendo io, per non fare 
confusione, come lo chiami ?
 
 
 
 
 

 confusione, come lo chiami ?
 
Carattere.
In pratica questa ambivalenza dei nomi "byte" e "char" non c'è mai, visto che
di solito dal contesto è abbastanza chiaro se vogliamo il byte macchina,
CHAR_BIT bits oppure il carattere '爱'.
Purtroppo dobbiamo portarci dietro anni di evoluzioni che hanno lasciato
traccia di qualche errore o ambiguità, ma alla fine è il male minore :)
Ciao!


Si, certo,  è un male minore dovuto a ragioni storiche
Basta semplicemente intendersi
 

 UTF8) la lunghezza in byte dipende dal carattere
 
Carattere. char è il tipo di una variabile destinata a contenere 
un carattere tipografico o di controllo, byte è una sequenza di 
otto bit senza nessun significato particolare.
La cosa non è stata mai messa in discussione tanto e vero che
altri linguaggi distinguono il tipo byte dal tipo carattere, 
indipendentemente dalla codifica ASCI, BCDIC, Unicode o
mariafrancesca. e indipendentemente se il byte è cinque, sei 
o otto bit.
Poi il C, nella sua economia ed essenzialità definisce solo 
il char e int è un altro discorso. E non è poi tanto vero; le 
molte implementazioni del C definiscono i tipi interi come 
char, short, int, long e long long int e le loro lunghezze 
effettive in bit sono funzione della macchina; AFAIK byte
su una certa macchina potrebbe benissimo essere 
implementato con unsigned short int e come long int su 
un'altra.
 
 
 

 
 
Occhio a generalizzare, che quando si parla di testo, la dimensione in bit
di un carattere dipende sia dalla codifica utilizzata sia dal carattere stesso.
 
Ciao!

 stesso.
 
Ed è una delle cose che non ho detto per non appesantire il discorso.

 la morte, che sia uguale ad un byte è un'altra faccenda.
 
il tipo del C denominato char e' un byte, comunque sia definito il
byte
su una certa macchina. Questa e' una delle pochissime cose su cui puoi
scommettere cone certezza matematica di vincere. Il char di cui stai
discutendo tu, non ha niente a che vedere con il char dell'OP o con il
char definito dallo standard. Chiarisciti un attimo le idee, o in
alternativa
convinciti di aver detto una castroneria.
 
C:\>iao Angelo

 un'altra.
 
Quello che puo' essere e' che su certe macchine un long int sia
un byte. Quello che e' certo e' che su qualsiasi macchina un char
e' pari ad un byte.
 
C:\>iao Angelo