Inizializzazione della struttura C ++

È possibile inizializzare le strutture in C ++ come indicato di seguito

struct address {
    int street_no;
    char *street_name;
    char *city;
    char *prov;
    char *postal_code;
};
address temp_address =
    { .city = "Hamilton", .prov = "Ontario" };

I collegamenti qui e qui menzionano che è possibile utilizzare questo stile solo in C. In caso affermativo, perché non è possibile in C ++? C'è qualche motivo tecnico di fondo per cui non è implementato in C ++, o è una cattiva pratica usare questo stile? Mi piace usare questo modo di inizializzare perché la mia struttura è grande e questo stile mi dà una chiara leggibilità di quale valore è assegnato a quale membro.

Per favore condividi con me se ci sono altri modi in cui possiamo ottenere la stessa leggibilità.

Ho fatto riferimento ai seguenti link prima di pubblicare questa domanda

1. C / C ++ per AIX
2. Inizializzazione della struttura C con variabile
3. Inizializzazione della struttura statica con tag in C ++
4. C ++ 11 Inizializzazione della struttura corretta

Se vuoi chiarire qual è il valore di ciascun inizializzatore, basta dividerlo su più righe, con un commento su ciascuno:

address temp_addres = {
  0,  // street_no
  nullptr,  // street_name
  "Hamilton",  // city
  "Ontario",  // prov
  nullptr,  // postal_code
};

Dopo che la mia domanda non ha prodotto risultati soddisfacenti (poiché C ++ non implementa init basato su tag per strutture), ho preso il trucco che ho trovato qui: I membri di una struttura C ++ sono inizializzati su 0 per impostazione predefinita?

Per te equivarrebbe a farlo:

address temp_address = {}; // will zero all fields in C++
temp_address.city = "Hamilton";
temp_address.prov = "Ontario";

Questo è sicuramente il più vicino a quello che volevi originariamente (azzera tutti i campi tranne quelli che vuoi inizializzare).

Come altri hanno già detto, questo è designato inizializzatore.

Questa funzione fa parte di C ++ 20

Gli identificatori di campo sono in effetti la sintassi dell'inizializzatore C. In C ++ basta dare i valori nell'ordine corretto senza i nomi dei campi. Sfortunatamente questo significa che devi dare loro tutti (in realtà puoi omettere i campi finali a zero e il risultato sarà lo stesso):

address temp_address = { 0, 0, "Hamilton", "Ontario", 0 }; 

Questa funzione è chiamata inizializzatori designati . È un'aggiunta allo standard C99. Tuttavia, questa funzionalità è stata lasciata fuori dal C ++ 11. Secondo The C ++ Programming Language, 4th edition, Section 44.3.3.2 (C Features non adottato da C ++):

Alcune aggiunte a C99 (rispetto a C89) non sono state deliberatamente adottate in C ++:

[1] Array a lunghezza variabile (VLA); usa il vettore o una qualche forma di matrice dinamica

[2] inizializzatori designati; usare i costruttori

La grammatica C99 ha gli inizializzatori designati [Vedi ISO / IEC 9899: 2011, N1570 Committee Draft - 12 aprile 2011]

6.7.9 Inizializzazione

initializer:
    assignment-expression
    { initializer-list }
    { initializer-list , }
initializer-list:
    designation_opt initializer
    initializer-list , designationopt initializer
designation:
    designator-list =
designator-list:
    designator
    designator-list designator
designator:
    [ constant-expression ]
    . identifier

D'altra parte, il C ++ 11 non ha gli inizializzatori designati [Vedi ISO / IEC 14882: 2011, N3690 Committee Draft - 15 maggio 2013]

8.5 Inizializzatori

initializer:
    brace-or-equal-initializer
    ( expression-list )
brace-or-equal-initializer:
    = initializer-clause
    braced-init-list
initializer-clause:
    assignment-expression
    braced-init-list
initializer-list:
    initializer-clause ...opt
    initializer-list , initializer-clause ...opt
braced-init-list:
    { initializer-list ,opt }
    { }

Per ottenere lo stesso effetto, utilizzare i costruttori o gli elenchi di inizializzatori:

Puoi solo inizializzare tramite ctor:

struct address {
  address() : city("Hamilton"), prov("Ontario") {}
  int street_no;
  char *street_name;
  char *city;
  char *prov;
  char *postal_code;
};

Puoi persino comprimere la soluzione di Gui13 in una singola dichiarazione di inizializzazione:

struct address {
                 int street_no;
                 char *street_name;
                 char *city;
                 char *prov;
                 char *postal_code;
               };


address ta = (ta = address(), ta.city = "Hamilton", ta.prov = "Ontario", ta);

Disclaimer: non consiglio questo stile

So che questa domanda è piuttosto vecchia, ma ho trovato un altro modo di inizializzare, usando constexpr e curry:

struct mp_struct_t {
    public:
        constexpr mp_struct_t(int member1) : mp_struct_t(member1, 0, 0) {}
        constexpr mp_struct_t(int member1, int member2, int member3) : member1(member1), member2(member2), member3(member3) {}
        constexpr mp_struct_t another_member(int member) { return {member1, member,     member2}; }
        constexpr mp_struct_t yet_another_one(int member) { return {member1, member2, member}; }

    int member1, member2, member3;
};

static mp_struct_t a_struct = mp_struct_t{1}
                           .another_member(2)
                           .yet_another_one(3);

Questo metodo funziona anche per variabili statiche globali e anche per quelle di constexpr. L'unico svantaggio è la cattiva manutenibilità: ogni volta che un altro membro deve essere reso inizializzabile usando questo metodo, tutti i metodi di inizializzazione del membro devono essere cambiati.

Potrei mancare qualcosa qui, perché no:

#include <cstdio>    
struct Group {
    int x;
    int y;
    const char* s;
};

int main() 
{  
  Group group {
    .x = 1, 
    .y = 2, 
    .s = "Hello it works"
  };
  printf("%d, %d, %s", group.x, group.y, group.s);
}

Non è implementato in C ++. (anche, char*stringhe? Spero di no).

Di solito se hai così tanti parametri è un odore di codice abbastanza serio. Ma invece, perché non semplicemente inizializzare il valore della struttura e quindi assegnare ciascun membro?

Ho trovato questo modo di farlo per le variabili globali, che non richiede di modificare la definizione della struttura originale:

struct address {
             int street_no;
             char *street_name;
             char *city;
             char *prov;
             char *postal_code;
           };

quindi dichiarare la variabile di un nuovo tipo ereditata dal tipo di struttura originale e utilizzare il costruttore per l'inizializzazione dei campi:

struct temp_address : address { temp_address() { 
    city = "Hamilton"; 
    prov = "Ontario"; 
} } temp_address;

Non abbastanza elegante come lo stile C però ...

Per una variabile locale richiede un memset aggiuntivo (this, 0, sizeof (* this)) all'inizio del costruttore, quindi chiaramente non è peggio e la risposta di @ gui13 è più appropriata.

(Si noti che "temp_address" è una variabile di tipo "temp_address", tuttavia questo nuovo tipo eredita da "address" e può essere utilizzato in ogni luogo in cui è previsto "address", quindi va bene.)

Ho affrontato un problema simile oggi, dove ho una struttura che voglio riempire di dati di test che verranno passati come argomenti a una funzione che sto testando. Volevo avere un vettore di queste strutture e stavo cercando un metodo one-liner per inizializzare ogni struttura.

Ho finito con una funzione di costruzione nella struttura, che credo sia stata suggerita anche in alcune risposte alla tua domanda.

Probabilmente è una cattiva pratica avere gli argomenti per il costruttore con gli stessi nomi delle variabili dei membri pubblici, che richiedono l'uso del thispuntatore. Qualcuno può suggerire una modifica se esiste un modo migliore.

typedef struct testdatum_s {
    public:
    std::string argument1;
    std::string argument2;
    std::string argument3;
    std::string argument4;
    int count;

    testdatum_s (
        std::string argument1,
        std::string argument2,
        std::string argument3,
        std::string argument4,
        int count)
    {
        this->rotation = argument1;
        this->tstamp = argument2;
        this->auth = argument3;
        this->answer = argument4;
        this->count = count;
    }

} testdatum;

Che ho usato nella mia funzione di test per chiamare la funzione testata con vari argomenti come questo:

std::vector<testdatum> testdata;

testdata.push_back(testdatum("val11", "val12", "val13", "val14", 5));
testdata.push_back(testdatum("val21", "val22", "val23", "val24", 1));
testdata.push_back(testdatum("val31", "val32", "val33", "val34", 7));

for (std::vector<testdatum>::iterator i = testdata.begin(); i != testdata.end(); ++i) {
    function_in_test(i->argument1, i->argument2, i->argument3, i->argument4m i->count);
}

È possibile, ma solo se la struttura che stai inizializzando è una struttura POD (semplici vecchi dati). Non può contenere metodi, costruttori o valori predefiniti.

In C ++ gli inizializzatori in stile C sono stati sostituiti da costruttori che in fase di compilazione possono garantire che vengano eseguite solo inizializzazioni valide (cioè dopo l'inizializzazione i membri dell'oggetto sono coerenti).

È una buona pratica, ma a volte una pre-inizializzazione è utile, come nel tuo esempio. OOP risolve questo problema con classi astratte o modelli di progettazione creazionale .

A mio avviso, l'utilizzo di questo modo sicuro uccide la semplicità e talvolta il compromesso di sicurezza potrebbe essere troppo costoso, poiché un semplice codice non ha bisogno di un design sofisticato per rimanere sostenibile.

Come soluzione alternativa, suggerisco di definire le macro usando lambdas per semplificare l'inizializzazione in modo che assomigli quasi allo stile C:

struct address {
  int street_no;
  const char *street_name;
  const char *city;
  const char *prov;
  const char *postal_code;
};
#define ADDRESS_OPEN [] { address _={};
#define ADDRESS_CLOSE ; return _; }()
#define ADDRESS(x) ADDRESS_OPEN x ADDRESS_CLOSE

La macro ADDRESS si espande in

[] { address _={}; /* definition... */ ; return _; }()

che crea e chiama la lambda. Anche i parametri macro sono separati da virgola, quindi è necessario mettere l'inizializzatore tra parentesi e chiamare like

address temp_address = ADDRESS(( _.city = "Hamilton", _.prov = "Ontario" ));

È inoltre possibile scrivere un inizializzatore di macro generalizzato

#define INIT_OPEN(type) [] { type _={};
#define INIT_CLOSE ; return _; }()
#define INIT(type,x) INIT_OPEN(type) x INIT_CLOSE

ma poi la chiamata è leggermente meno bella

address temp_address = INIT(address,( _.city = "Hamilton", _.prov = "Ontario" ));

tuttavia è possibile definire facilmente la macro ADDRESS utilizzando la macro INIT generale

#define ADDRESS(x) INIT(address,x)

In GNUC ++ (sembra essere obsoleto dal 2.5, molto tempo fa :) Vedi le risposte qui: inizializzazione della struttura usando le etichette. Funziona, ma come? ), è possibile inizializzare una struttura come questa:

struct inventory_item {
    int bananas;
    int apples;
    int pineapples;
};

inventory_item first_item = {
    bananas: 2,
    apples: 49,
    pineapples: 4
};

Ispirato da questa risposta davvero accurata: ( https://stackoverflow.com/a/49572324/4808079 )

Puoi fare chiusure di lamba:

// Nobody wants to remember the order of these things
struct SomeBigStruct {
  int min = 1;
  int mean = 3 ;
  int mode = 5;
  int max = 10;
  string name;
  string nickname;
  ... // the list goes on
}

.

class SomeClass {
  static const inline SomeBigStruct voiceAmps = []{
    ModulationTarget $ {};
    $.min = 0;  
    $.nickname = "Bobby";
    $.bloodtype = "O-";
    return $;
  }();
}

Oppure, se vuoi essere molto elegante

#define DesignatedInit(T, ...)\
  []{ T ${}; __VA_ARGS__; return $; }()

class SomeClass {
  static const inline SomeBigStruct voiceAmps = DesignatedInit(
    ModulationTarget,
    $.min = 0,
    $.nickname = "Bobby",
    $.bloodtype = "O-",
  );
}

Ci sono alcuni inconvenienti coinvolti in questo, principalmente con membri non inizializzati. Da quello che dicono i commenti delle risposte collegate, si compila in modo efficiente, anche se non l'ho provato.

Nel complesso, penso solo che sia un approccio pulito.