Newsgroup: it.comp.lang.c
Titolo: Re: array di zero elementi

 riga di codice...
struct __flow_table {
uint32_t tstamp_hi;
uint32_t size;
uint32_t entries;
uint32_t records;
uint32_t live_buckets;
uint32_t first_full;
handler_t *handlers;
memlist_t *mem;
void *flowset_info;
flow_table *next_expired;
flow_hdr *bucket[0]; /* pointers to flows -- "size" entries */
};
l'ultima dichiarazione è quella che non capisco?!
Regards
LUC!4N0

 generico :) )
Di sicuro avrai visto una cosa del genere
typedef struct
{
   int nElems;
   char arr[0];
} PIPPO;
Questo tipo di struttura serve fare cose del genere
int main(void)
{
   int idx = 0;
   PIPPO* pippoP = NULL;
   pippoP = malloc(sizeof(PIPPO) +50);
   if(NULL != pippoP)
   {
      pippoP->nElems = 50;
      memset(&pippoP->arr, 'A', pippoP->nElems);
      while(idx < pippoP->nElems)
      {
         printf("%c\n", pippoP->arr[idx]);
         idx++;
      }
   }
   return 0;
}
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG


Ciao e Grazie mille
LUC!4N0

 l'ultima dichiarazione è quella che non capisco?!
Io sono un po' sconvolto! in quanto non ho mai visto niente del genere,
comunque ti dovrebbe aver risposto Angelo Paolitto e quindi dovrebbe servire
da "secchiello" per eventuali dati di dimensione variabile o comunque che
non abbisognano di essere strutturati ma almeno contenuti, o qualcosa del
genere...

 tipo *puntatore[0];
io non ho mai visto una cosa del genere!!
cioè è un array di puntatori a tipo di zero elementi!?!? 

 Stampa:
E:\USER\NS\CPP\quickTest\quickTest.c(53) : error C2229: struct
'lupo' has an illegal zero-sized array
Mai fare cieco affidamento sul comportamento di un compilatore.
C:\>iao Angelo


Grazie di tutto
LUC!4N0

 in più rispetto a dichiarare un puntatore a char ??
Scusa, ma non ho capito cosa vuoi chiedermi...
C:\>iao Angelo


 Incomprensibilita' riguardo a cosa?
Il codice che hai postato definisce una struttura con alla fine
un char pippo[0];
poi allochi memoria per la struttura aggiungendo 50 bytes
che dovrebbero appartenere a char pippo[0];
poi setti i 50 bytes a 'A' e li memorizzi in *pippo*.
Insomma, se ho capito bene, alla fine hai una variabile struttura con 
all'interno
un "puntatore" ad un array di 50 char
Invece usando char *pippo e allocando dopo i 50 bytes ecc...
ottieni lo stesso risultato;
La prima forma non è un tantino incomprensibile??

 La prima forma non è un tantino incomprensibile??
Utilizzando un puntatore le cose funzionano lo stesso, ma il codice,
nel caso di dbm ad es., si complicherebbe.
E se vuoi vedere del codice veramente incomprensibile
(size_t)&(((PIPPO*)NULL)->arr); [1]
:-)
C:\>iao Angelo
[1] Se qualcuno sa perche' funziona, sia cosi gentile da farlo sapere
    pure a me...


 pure a me...
Direi che è un'espressione che sfrutta l'aritmetica dei puntatori per
calcolare l'offset del campo "arr" in una struttura "PIPPO".
Ma è un metodo sbagliato: funziona solo se NULL è zero ma, secondo lo
standard, potrebbe anche non esserlo. Un modo più corretto potrebbe essere:
   (size_t) ((char *)(&(((PIPPO*)NULL)->arr))) - ((char *)NULL))
... che come incomprensibilità è ancora più figo! :-)
Oppure, in modo molto più semplice e standard:
   offsetof(PIPPO, arr)
La macro "offsetof" è prevista dal C99 e dovrebbe stare in <stddef.h>.
--
Cingar
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

 La macro "offsetof" è prevista dal C99 e dovrebbe stare in <stddef.h>.
E secondo te dove l'ho preso quel codice? :-)
C:\>iao Angelo


 continua a sfuggirmi.
Evidentemente a non sussistere e' proprio l'accesso.
Non conosco gli standard e non ho neanche letto il K&R perche' a suo tempo
alle medie non lo capivo :) ma immagino che a livello pratico l'operatore &
e tutto quello che lo segue vengano trasformati in un indirizzo senza
necessita' di accedere, a tempo di esecuzione, all'oggetto referenziato,
giacche' a livello macchina per accedere a una variabile (=spazio allocato
in memoria) bisogna conoscerne l'indirizzo, piuttosto che viceversa. 
Per cui il compiler generera' codice tale da prendere l'indirizzo di un 
oggetto di tipo PIPPO (qui esplicitamente NULL) e sommarlo all'offset
dell'elemento arr rispetto all'inizio della struttura. 
Che l'oggetto si trovi nello stack o a NULL o su Fomalhaut, poco cambia..
no access no cry. :D  
IMHO.
-- 
Giuseppe

 (size_t)&(((PIPPO*)NULL)->arr); [1]
AHH PERO''!!!