Conveniente inicialización de estructura C ++

Estoy tratando de encontrar una manera conveniente de inicializar las estructuras C ++ 'pod'. Ahora, considere la siguiente estructura:

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

Si quiero iniciar esto convenientemente en C (!), Simplemente podría escribir:

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

Tenga en cuenta que quiero evitar explícitamente la siguiente notación, porque me parece que me rompen el cuello si cambio algo en la estructura en el futuro:

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

Para lograr lo mismo (o al menos similar) en C ++ como en el /* A */ejemplo, tendría que implementar un constructor idiota:

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

Lo cual es bueno para hervir agua, pero no es adecuado para personas perezosas (la pereza es algo bueno, ¿verdad?). Además, es casi tan malo como el /* B */ejemplo, ya que no establece explícitamente qué valor va a qué miembro.

Entonces, mi pregunta es básicamente ¿cómo puedo lograr algo similar /* A */o mejor en C ++? Alternativamente, estaría de acuerdo con una explicación de por qué no debería querer hacer esto (es decir, por qué mi paradigma mental es malo).

EDITAR

Por conveniente , quiero decir también mantenible y no redundante .

Las inicializaciones designadas serán compatibles con c ++ 2a, pero no tiene que esperar, ya que oficialmente son compatibles con GCC, Clang y 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

Como style Ano está permitido en C ++ y no quieres style B, ¿qué tal si usas style BX:

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

Al menos ayuda en alguna medida.

Podrías usar una lambda:

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

Se puede encontrar más información sobre este idioma en el blog de Herb Sutter .

Extraiga los contenidos en funciones que los describen (refactorización básica):

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

Sé que el estilo es muy cercano al que no quería usar, pero permite reemplazar más fácilmente los valores constantes y también explicarlos (por lo tanto, no es necesario editar comentarios), si alguna vez cambian, eso es.

Otra cosa que podrías hacer (ya que eres flojo) es hacer que el constructor esté en línea, para que no tengas que escribir tanto (eliminando "Foobar ::" y el tiempo dedicado a cambiar entre el archivo h y cpp):

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

Su pregunta es algo difícil porque incluso la función:

static FooBar MakeFooBar(int foo, float bar);

puede ser llamado como:

FooBar fb = MakeFooBar(3.4, 5);

debido a las reglas de promoción y conversiones para los tipos numéricos integrados. (C nunca ha sido muy fuertemente tipado)

En C ++, lo que quiere se puede lograr, aunque con la ayuda de plantillas y afirmaciones estáticas:

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 };
}

En C, puede nombrar los parámetros, pero nunca llegará más lejos.

Por otro lado, si todo lo que quieres son parámetros nombrados, entonces escribes mucho código engorroso:

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);

Y puede agregarle protección de promoción tipo si lo desea.

Las interfaces de C ++ de muchos compiladores (incluidos GCC y clang) entienden la sintaxis del inicializador de C. Si puedes, simplemente usa ese método.

Otra forma más en C ++ es

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);

Opción D:

FooBar FooBarMake(int foo, float bar)

Legal C, legal C ++. Fácilmente optimizable para POD. Por supuesto, no hay argumentos con nombre, pero esto es como todos los C ++. Si desea argumentos con nombre, el objetivo C debería ser una mejor opción.

Opción E:

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

Legal C, legal C ++. Argumentos nombrados.

Sé que esta pregunta es antigua, pero hay una manera de resolver esto hasta que C ++ 20 finalmente traiga esta característica de C a C ++. Lo que puede hacer para resolver esto es usar macros de preprocesador con static_asserts para verificar que su inicialización sea válida. (Sé que las macros son generalmente malas, pero aquí no veo otra forma). Vea el código de ejemplo a continuación:

#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...

Luego, cuando tenga una estructura con atributos const, puede hacer esto:

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.);

Es un poco incómodo, porque necesita macros para cada número posible de atributos y necesita repetir el tipo y el nombre de su instancia en la llamada de macro. Además, no puede usar la macro en una declaración de devolución, porque las afirmaciones vienen después de la inicialización.

Pero sí resuelve su problema: cuando cambia la estructura, la llamada fallará en tiempo de compilación.

Si usa C ++ 17, incluso puede hacer que estas macros sean más estrictas al forzar los mismos tipos, por ejemplo:

#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);\

La forma /* B */está bien en C ++, también C ++ 0x va a extender la sintaxis, por lo que también es útil para contenedores C ++. No entiendo por qué lo llamas mal estilo?

Si desea indicar parámetros con nombres, puede usar la biblioteca de parámetros de impulso , pero puede confundir a alguien que no esté familiarizado con ellos.

Reordenar los miembros de la estructura es como reordenar los parámetros de la función, tal refactorización puede causar problemas si no lo hace con mucho cuidado.

¿Qué pasa con esta sintaxis?

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

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

Acabo de probar en un Microsoft Visual C ++ 2015 y en g ++ 6.0.2. Trabajando bien
También puede hacer una macro específica si desea evitar duplicar el nombre de la variable.

Para mí, la forma más perezosa de permitir la inicialización en línea es usar esta 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);

Esa macro crea atributo y método de autorreferencia.