Newsgroup: it.comp.os.linux.development
Titolo: Calcolare size of void

Salve a tutti
mi riallaccio alla discussione su "instradare senza memorizzare"
apro un altro topic perchè credo che questo interessi molti
programmatori.
Data una variabile void , c'è un modo per calcolare il suo size ?
cerco di essere + esplicativo con questo frammento di codice :
int main()
{
	int vett[5];
	funct(vett);
}
void funct (void * buff)
{
	printf("sizeof(buff) = %d            sizeof(*buff) = %d
\n",sizeof(buff),sizeof(*buff));
}
in questo caso vorrei sapere nella printf della funzione che l'array
vett sia grande
5 interi, ovviamente quando eseguo ho questo risultato :
sizeof(buff) = 4            sizeof(*buff) = 1
il risultato è lo stesso , anche se dichiaro vett di 10 elementi.
Dato che devo sviluppare la funzione funct() e non posso modificare i
parametri di input
che non comprendono il size di buff ...
vorrei sapere se c'è un modo di sapere il vero size di buff.
Grazie

 vorrei sapere se c'è un modo di sapere il vero size di buff.
no

 sizeof(buff) = 4            sizeof(*buff) = 1
"Ovviamente" no. E' un'estensione del gcc. A norma di standard
sizeof(void) non ha senso.
Luca
-- 
Colui che sorride quando le cose vanno male ha pensato a qualcuno a cui
dare la colpa.

 sizeof(void) non ha senso.
Piu' che un'estensione, io lo considererei un bug.
Se fosse una feature dovrebbe avere una qualche utilita', ma in questo
caso non riesco proprio ad immaginare a cosa possa servire.
Saluti,
The Librarian

 sizeof(void) non ha senso.
A norma di standard sizeof(void) e` undefined. Quindi qualunque valore
e` buono. Che gcc ritorni 1 non e` un'estensione ma una scelta della
implementazione. Una scelta discutibile, forse...
Ciao,
-- 
        Roberto Divia`              Love at first sight is one of the greatest
Dep:PH Bat:53 Mailbox:C02110      labour-saving devices the world has ever seen
Route de Meyrin 385               ---------------------------------------------
Case Postale                                Phone:  
+41-22-767-4994
CH-1211 Geneve 23 CERN                      Fax:    
+41-22-767-9585
Switzerland                                 E-Mail: 
Robert...@cern.ch

 implementazione. Una scelta discutibile, forse...
Grazie della precisazione. Ne approfitto per chiederti qualche
ulteriore chiarimento.
Ho dato un'occhiata allo standard pero' non sono sicuro di aver capito
come si dovrebbe comportare il compilatore in questo caso.
Da quello che ho capito:
(1) void e' un tipo incompleto
(2) l'operatore sizeof ha come contraint che non deve essere applicato
a tipi incompleti
(3) Una violazione del constraint comporta un undefined behavior
(4) Un compilatore conforme allo standard deve sempre diagnosticare
una violazione di un constraint
Dal punto (4) deduco che quantomeno il compilatore debba riportare un
warning se si effettua "sizeof(void)" e che se non produce nessun
messaggio di diagnostica non e' conforme allo standard. Pero' potrebbe
benissimo riportare un errore al posto di un warning. Ho capito bene?
Saluti,
The Librarian

 benissimo riportare un errore al posto di un warning. Ho capito bene?
Quel che potrebbe e quel che dovrebbe non sono la stessa cosa...
In ogni caso, sono d'accordo con te, un bel warning ci sta bene.
Esistono pero` dei casi dove il comportamento non e` cosi` chiaro.
Prendiamo per esempio un puntatore anonimo completato a runtime:
int   i;
void *p = &i;
int   x = sizeof( *p );  /* Che fare? */
Il secondo statement e` incompleto, ma potrebbe diventare completo se
il compilatore sviluppa il flusso del codice. sizeof( i ) nell'esempio
e` perfettamente legale.
In ogni caso, sono dettagli...


 
No, e peraltro non lo vedo neppure utile. Se, nello specifico, salta fuori che 
hai bisogno di sapere il sizeof di un parametro passato come void*, allora c'è 
qualcosa di errato nel design.
-- 
SF
"Spartani... mangiate tanto a colazione perchè stasera ceneremo nell'Ade!!"

 void*, allora c'è qualcosa di errato nel design.
Concordo.
Io farei passare il size di buff come parametro alla funzione... Visto che
non vuoi cambiare le chiamate, con qualche macro ben aggiustata potresti
(ripeto: potresti) riuscire a farlo, sempre che tutti i chiamanti usino
un prototipo comune.


 
quoto. Se stesse usando il c++ qualche idea ce l'avrei pure..


 e` perfettamente legale.
L'analisi statica del codice da parte del compilatore non basta, ad
esempio:
int i;
short j;
void* p;
if( external_trigger())
{
    p = &i;
}
else
{
    p = &j;
}
Questa cosa si può fare solo a runtime, ad esempio usando qualcosa di
simile alla RTTI del C++ (oppure progettando il software in modo migliore).
-- 
emboliaschizoide.splinder.com