Come inizializzare una struttura con membro di matrice flessibile

Question

ho la seguente struttura

typedef struct _person { 
    int age; 
    char sex; 
    char name[]; 
}person; 

Ho fatto qualche ricerca su Internet di base (ma senza successo) su come creare un'istanza e inizializzare una struttura con un membro di matrice flessibile senza usare malloc().

Ad esempio: per strutture normali come

struct a { 
    int age; 
    int sex; 
}; 

Possiamo creare un'istanza di struct a e inizializzarlo come

struct a p1 = {10, 'm'}; 

Ma per strutture con matrice flessibile in esso (come _person come menzionato sopra) come possiamo creare un'istanza e inizializzarla come lo facciamo per il normale structures?

È possibile? In tal caso, come si passa la dimensione dell'array durante l'inizializzazione e il valore effettivo da inizializzare?

(o)

E 'vero che l'unico modo per creare una struttura con matrice flessibile sta usando malloc() come indicato nella specifica C99 - 6.7.2.1 Structure and union specifiers - point #17?!

Answer 1

No, gli array flessibili devono sempre essere assegnati manualmente. Ma è possibile utilizzare calloc per inizializzare la parte flessibile e un valore letterale composto per inizializzare la parte fissa. Mi piacerebbe che in un avvolgo inline funzione di allocazione in questo modo:

typedef struct person { 
    unsigned age; 
    char sex; 
    size_t size; 
    char name[]; 
} person; 

inline 
person* alloc_person(int a, char s, size_t n) { 
    person * ret = calloc(sizeof(person) + n, 1); 
    if (ret) memcpy(ret, 
        &(person const){ .age = a, .sex = s, .size = n}, 
        sizeof(person)); 
    return ret; 
} 

Si osservi che questo lascia il controllo se l'assegnazione è riuscita al chiamante.

Se non è necessario un campo size come ho incluso qui, una macro sarebbe addirittura sufficiente. Solo che non sarebbe possibile verificare la restituzione di calloc prima di eseguire lo memcpy. Sotto tutti i sistemi che ho programmato finora, questo si annullerà in modo relativamente gradevole. Generalmente penso che sia return of malloc is of minor importance, ma le opinioni variano ampiamente su quell'argomento.

Questo potrebbe forse (in questo caso particolare) danno maggiori opportunità di l'ottimizzatore di integrare il codice nei dintorni:

#define ALLOC_PERSON(A, S, N)         \ 
((person*)memcpy(calloc(sizeof(person) + (N), 1),    \ 
       &(person const){ .age = (A), .sex = (S) },  \ 
       sizeof(person))) 

Edit: Il caso che questo potrebbe essere migliore di funzione è quando A e S sono costanti di tempo di compilazione.In tal caso il composto letterale, dal momento che è qualificato const, potrebbe essere allocato staticamente e la sua inizializzazione potrebbe essere eseguita in fase di compilazione. Inoltre, se nel codice venissero visualizzate più allocazioni con gli stessi valori, al compilatore sarebbe permesso di realizzare solo una singola copia di quel composto letterale.

Answer 2

Un tipo di struttura con un membro di matrice flessibile può essere trattato come se il membro di matrice flessibile fosse omesso, quindi è possibile inizializzare la struttura in questo modo.

person p = { 10, 'x' }; 

Tuttavia, non ci sono membri della matrice flessibile assegnato e qualsiasi tentativo di accedere a un membro della matrice flessibile o formare un puntatore a una oltre la sua estremità è valido. L'unico modo per creare un'istanza di una struttura con un membro di matrice flessibile che abbia effettivamente elementi in questo array è allocare dinamicamente memoria per esso, ad esempio con malloc.

Answer 3

Ci sono alcuni trucchi che è possibile utilizzare. Dipende dalla tua particolare applicazione.

Se si desidera inizializzare una singola variabile, è possibile definire una struttura di dimensioni corrette:

struct { 
     int age; 
     char sex; 
     char name[sizeof("THE_NAME")]; 
    } your_variable = { 55, 'M', "THE_NAME" }; 

Il problema è che si deve utilizzare il puntatore casting per interpretare la variabile come "persona" (ad esempio, . "* (persona *) (& your_variable)" Ma è possibile utilizzare un sindacato che contiene per evitare questo:.

union { 
struct { ..., char name[sizeof("THE_NAME")]; } x; 
person p; 
} your_var = { 55, 'M', "THE_NAME" }; 

così, your_var.p è di tipo "persona" si può anche usare una macro per definisci il tuo inizializzatore, così puoi scrivere la stringa o n una volta:

#define INIVAR(x_, age_, sex_ ,s_) \ 
    union {\ 
    struct { ..., char name[sizeof(s_)]; } x;\ 
    person p;\ 
    } x_ = { (age_), (sex_), (s_) } 

INIVAR(your_var, 55, 'M', "THE NAME"); 

Un altro problema è che questo trucco non è adatto per creare un array di "persona". Il problema con gli array è che tutti gli elementi devono avere la stessa dimensione. In questo caso è più sicuro utilizzare const char * anziché char[]. Oppure utilizzare l'allocazione dinamica;)