Comoda inizializzazione della struttura in C ++

Sto cercando di trovare un modo conveniente per inizializzare le strutture C ++ 'pod'. Ora, considera la seguente struttura:

struct FooBar {
  int foo;
  float bar;
};
// just to make all examples work in C and C++:
typedef struct FooBar FooBar;

Se voglio inizializzare comodamente questo in C (!), Potrei semplicemente scrivere:

/* A */ FooBar fb = { .foo = 12, .bar = 3.4 }; // illegal C++, legal C

Nota che voglio evitare esplicitamente la seguente notazione, perché mi sembra che mi sia fatto spezzare il collo se in futuro cambio qualcosa nella struttura:

/* B */ FooBar fb = { 12, 3.4 }; // legal C++, legal C, bad style?

Per ottenere lo stesso (o almeno simile) in C ++ come /* A */nell'esempio, dovrei implementare un costruttore idiota:

FooBar::FooBar(int foo, float bar) : foo(foo), bar(bar) {}
// ->
/* C */ FooBar fb(12, 3.4);

Che è buono per l'acqua bollente, ma non adatto per le persone pigre (la pigrizia è una buona cosa, giusto?). Inoltre, è praticamente negativo come /* B */nell'esempio, in quanto non indica esplicitamente quale valore va a quale membro.

Quindi, la mia domanda è sostanzialmente come posso ottenere qualcosa di simile /* A */o migliore in C ++? In alternativa, starei bene con una spiegazione del perché non dovrei voler fare questo (cioè perché il mio paradigma mentale è cattivo).

MODIFICARE

Per conveniente intendo anche mantenibile e non ridondante .

Le inizializzazioni designate saranno supportate in c ++ 2a, ma non devi aspettare, perché sono ufficialmente supportate da GCC, Clang e MSVC.

#include <iostream>
#include <filesystem>

struct hello_world {
    const char* hello;
    const char* world;
};

int main () 
{
    hello_world hw = {
        .hello = "hello, ",
        .world = "world!"
    };

    std::cout << hw.hello << hw.world << std::endl;
    return 0;
}

GCC Demo MSVC Demo

Poiché style Anon è consentito in C ++ e non si desidera style Bquindi che ne dite di usare style BX:

FooBar fb = { /*.foo=*/ 12, /*.bar=*/ 3.4 };  // :)

Almeno aiuto in una certa misura.

Puoi usare un lambda:

const FooBar fb = [&] {
    FooBar fb;
    fb.foo = 12;
    fb.bar = 3.4;
    return fb;
}();

Maggiori informazioni su questo idioma sono disponibili sul blog di Herb Sutter .

Estrarre i concorrenti in funzioni che li descrivono (refactoring di base):

FooBar fb = { foo(), bar() };

So che lo stile è molto vicino a quello che non volevi usare, ma consente una più facile sostituzione dei valori costanti e li spiega anche (quindi non è necessario modificare i commenti), se mai cambiano.

Un'altra cosa che potresti fare (dato che sei pigro) è rendere in linea il costruttore, quindi non devi digitare troppo (rimuovendo "Foobar ::" e il tempo impiegato per passare dal file h al file cpp):

struct FooBar {
  FooBar(int f, float b) : foo(f), bar(b) {}
  int foo;
  float bar;
};

La tua domanda è alquanto difficile perché anche la funzione:

static FooBar MakeFooBar(int foo, float bar);

può essere chiamato come:

FooBar fb = MakeFooBar(3.4, 5);

a causa delle regole di promozione e conversione per i tipi numerici incorporati. (C non è mai stato davvero fortemente tipizzato)

In C ++, ciò che vuoi è realizzabile, anche se con l'aiuto di modelli e asserzioni statiche:

template <typename Integer, typename Real>
FooBar MakeFooBar(Integer foo, Real bar) {
  static_assert(std::is_same<Integer, int>::value, "foo should be of type int");
  static_assert(std::is_same<Real, float>::value, "bar should be of type float");
  return { foo, bar };
}

In C, puoi nominare i parametri, ma non otterrai mai di più.

D'altra parte, se tutto ciò che vuoi è denominato parametri, allora scrivi un sacco di codice ingombrante:

struct FooBarMaker {
  FooBarMaker(int f): _f(f) {}
  FooBar Bar(float b) const { return FooBar(_f, b); }
  int _f;
};

static FooBarMaker Foo(int f) { return FooBarMaker(f); }

// Usage
FooBar fb = Foo(5).Bar(3.4);

E se lo desideri puoi aggiungere la protezione promozione del tipo.

I frontend C ++ di molti compilatori (inclusi GCC e clang) comprendono la sintassi dell'inizializzatore C. Se puoi, usa semplicemente quel metodo.

Ancora un altro modo in C ++ è

struct Point
{
private:

 int x;
 int y;

public:
    Point& setX(int xIn) { x = Xin; return *this;}
    Point& setY(int yIn) { y = Yin; return *this;}

}

Point pt;
pt.setX(20).setY(20);

Opzione D:

FooBar FooBarMake(int foo, float bar)

C legale, C ++ legale. Facilmente ottimizzabile per i POD. Naturalmente non ci sono argomenti con nome, ma questo è come tutto il C ++. Se vuoi argomenti con nome, l'obiettivo C dovrebbe essere la scelta migliore.

Opzione E:

FooBar fb;
memset(&fb, 0, sizeof(FooBar));
fb.foo = 4;
fb.bar = 15.5f;

C legale, C ++ legale. Argomenti nominati.

So che questa domanda è vecchia, ma c'è un modo per risolverlo fino a quando C ++ 20 porta finalmente questa funzionalità da C a C ++. Quello che puoi fare per risolvere questo è usare le macro del preprocessore con static_asserts per verificare che l'inizializzazione sia valida. (So ​​che le macro sono generalmente sbagliate, ma qui non vedo un altro modo.) Vedi il codice di esempio di seguito:

#define INVALID_STRUCT_ERROR "Instantiation of struct failed: Type, order or number of attributes is wrong."

#define CREATE_STRUCT_1(type, identifier, m_1, p_1) \
{ p_1 };\
static_assert(offsetof(type, m_1) == 0, INVALID_STRUCT_ERROR);\

#define CREATE_STRUCT_2(type, identifier, m_1, p_1, m_2, p_2) \
{ p_1, p_2 };\
static_assert(offsetof(type, m_1) == 0, INVALID_STRUCT_ERROR);\
static_assert(offsetof(type, m_2) >= sizeof(identifier.m_1), INVALID_STRUCT_ERROR);\

#define CREATE_STRUCT_3(type, identifier, m_1, p_1, m_2, p_2, m_3, p_3) \
{ p_1, p_2, p_3 };\
static_assert(offsetof(type, m_1) == 0, INVALID_STRUCT_ERROR);\
static_assert(offsetof(type, m_2) >= sizeof(identifier.m_1), INVALID_STRUCT_ERROR);\
static_assert(offsetof(type, m_3) >= (offsetof(type, m_2) + sizeof(identifier.m_2)), INVALID_STRUCT_ERROR);\

#define CREATE_STRUCT_4(type, identifier, m_1, p_1, m_2, p_2, m_3, p_3, m_4, p_4) \
{ p_1, p_2, p_3, p_4 };\
static_assert(offsetof(type, m_1) == 0, INVALID_STRUCT_ERROR);\
static_assert(offsetof(type, m_2) >= sizeof(identifier.m_1), INVALID_STRUCT_ERROR);\
static_assert(offsetof(type, m_3) >= (offsetof(type, m_2) + sizeof(identifier.m_2)), INVALID_STRUCT_ERROR);\
static_assert(offsetof(type, m_4) >= (offsetof(type, m_3) + sizeof(identifier.m_3)), INVALID_STRUCT_ERROR);\

// Create more macros for structs with more attributes...

Quindi, quando si dispone di una struttura con attributi const, è possibile farlo:

struct MyStruct
{
    const int attr1;
    const float attr2;
    const double attr3;
};

const MyStruct test = CREATE_STRUCT_3(MyStruct, test, attr1, 1, attr2, 2.f, attr3, 3.);

È un po 'scomodo, perché hai bisogno di macro per ogni possibile numero di attributi e devi ripetere il tipo e il nome della tua istanza nella chiamata macro. Inoltre, non è possibile utilizzare la macro in un'istruzione return, poiché gli assert vengono dopo l'inizializzazione.

Ma risolve il tuo problema: quando cambi la struttura, la chiamata fallirà in fase di compilazione.

Se usi C ++ 17, puoi persino rendere più rigorose queste macro forzando gli stessi tipi, ad esempio:

#define CREATE_STRUCT_3(type, identifier, m_1, p_1, m_2, p_2, m_3, p_3) \
{ p_1, p_2, p_3 };\
static_assert(offsetof(type, m_1) == 0, INVALID_STRUCT_ERROR);\
static_assert(offsetof(type, m_2) >= sizeof(identifier.m_1), INVALID_STRUCT_ERROR);\
static_assert(offsetof(type, m_3) >= (offsetof(type, m_2) + sizeof(identifier.m_2)), INVALID_STRUCT_ERROR);\
static_assert(typeid(p_1) == typeid(identifier.m_1), INVALID_STRUCT_ERROR);\
static_assert(typeid(p_2) == typeid(identifier.m_2), INVALID_STRUCT_ERROR);\
static_assert(typeid(p_3) == typeid(identifier.m_3), INVALID_STRUCT_ERROR);\

In /* B */C ++ va bene anche il C ++ 0x estenderà la sintassi, quindi è utile anche per i contenitori C ++. Non capisco perché lo chiami cattivo stile?

Se vuoi indicare parametri con nomi, puoi usare la libreria di parametri boost , ma potresti confondere qualcuno che non ha familiarità con esso.

Il riordino dei membri della struttura è come il riordino dei parametri della funzione, tale refactoring può causare problemi se non lo si fa con molta attenzione.

Che dire di questa sintassi?

typedef struct
{
    int a;
    short b;
}
ABCD;

ABCD abc = { abc.a = 5, abc.b = 7 };

Appena testato su un Microsoft Visual C ++ 2015 e su g ++ 6.0.2. Funziona bene.
È possibile creare una macro specifica anche se si desidera evitare la duplicazione del nome della variabile.

Per me il modo più pigro per consentire l'inizializzazione in linea è usare questa macro.

#define METHOD_MEMBER(TYPE, NAME, CLASS) \
CLASS &set_ ## NAME(const TYPE &_val) { NAME = _val; return *this; } \
TYPE NAME;

struct foo {
    METHOD_MEMBER(string, attr1, foo)
    METHOD_MEMBER(int, attr2, foo)
    METHOD_MEMBER(double, attr3, foo)
};

// inline usage
foo test = foo().set_attr1("hi").set_attr2(22).set_attr3(3.14);

Quella macro crea l'attributo e il metodo di auto-riferimento.