Inicialização de estrutura C ++ conveniente

Estou tentando encontrar uma maneira conveniente de inicializar estruturas C ++ 'pod'. Agora, considere a seguinte estrutura:

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

Se eu quiser inicializar isso convenientemente em C (!), Eu poderia simplesmente escrever:

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

Observe que quero evitar explicitamente a seguinte notação, porque me parece que foi feita para quebrar meu pescoço se eu mudar alguma coisa na estrutura no futuro:

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

Para obter o mesmo (ou pelo menos semelhante) em C ++ como no /* A */exemplo, eu teria que implementar um construtor idiota:

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

O que é bom para ferver água, mas não é adequado para pessoas preguiçosas (a preguiça é uma coisa boa, certo?). Além disso, é tão ruim quanto o /* B */exemplo, pois não indica explicitamente qual valor vai para qual membro.

Então, minha pergunta é basicamente como eu posso conseguir algo semelhante a /* A */ ou melhor em C ++? Como alternativa, eu ficaria bem com uma explicação sobre por que não gostaria de fazer isso (ou seja, por que meu paradigma mental é ruim).

EDITAR

Por conveniente , quero dizer também de manutenção e não redundante .

Inicializações designadas serão suportadas no c ++ 2a, mas você não precisa esperar, porque elas são suportadas oficialmente pelo 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

Como style Anão é permitido em C ++ e você não deseja style B, que tal usar style BX:

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

Pelo menos ajuda até certo ponto.

Você poderia usar um lambda:

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

Mais informações sobre esse idioma podem ser encontradas no blog de Herb Sutter .

Extraia os conteúdos em funções que os descrevam (refatoração básica):

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

Eu sei que o estilo está muito próximo do que você não queria usar, mas permite a substituição mais fácil dos valores constantes e também os explica (portanto, não é necessário editar comentários), se eles mudarem.

Outra coisa que você pode fazer (já que você é preguiçoso) é tornar o construtor incorporado, para que você não precise digitar tanto (removendo "Foobar ::" e o tempo gasto alternando entre os arquivos he cpp):

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

Sua pergunta é um pouco difícil, porque até a função:

static FooBar MakeFooBar(int foo, float bar);

pode ser chamado como:

FooBar fb = MakeFooBar(3.4, 5);

devido às regras de promoção e conversões para tipos numéricos incorporados. (C nunca foi realmente fortemente digitado)

No C ++, o que você deseja é possível, embora com a ajuda de modelos e asserções 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 };
}

Em C, você pode nomear os parâmetros, mas nunca irá além.

Por outro lado, se tudo o que você deseja é nomeado parâmetros, você escreve muito código complicado:

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 você pode adicionar proteção de promoção de tipo, se quiser.

As interfaces C ++ de muitos compiladores (incluindo GCC e clang) entendem a sintaxe do inicializador C. Se você puder, basta usar esse método.

Ainda outra maneira em 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);

Opção D:

FooBar FooBarMake(int foo, float bar)

C legal, C ++ legal. Facilmente otimizável para PODs. Claro que não há argumentos nomeados, mas isso é como todo o C ++. Se você deseja argumentos nomeados, o Objetivo C deve ser a melhor escolha.

Opção E:

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

C legal, C ++ legal. Argumentos nomeados.

Eu sei que essa pergunta é antiga, mas há uma maneira de resolver isso até que o C ++ 20 finalmente traga esse recurso de C para C ++. O que você pode fazer para resolver isso é usar macros de pré-processador com static_asserts para verificar se a inicialização é válida. (Eu sei que as macros geralmente são ruins, mas aqui não vejo outra maneira.) Veja o código de exemplo abaixo:

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

Então, quando você tiver uma estrutura com atributos const, poderá fazer o seguinte:

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

É um pouco inconveniente, porque você precisa de macros para todos os números possíveis de atributos e precisa repetir o tipo e o nome da sua instância na chamada de macro. Além disso, você não pode usar a macro em uma declaração de retorno, porque as declarações vêm após a inicialização.

Mas isso resolve o seu problema: quando você altera a estrutura, a chamada falha no momento da compilação.

Se você usa C ++ 17, pode até tornar essas macros mais rigorosas forçando os mesmos tipos, por exemplo:

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

O caminho /* B */ é bom em C ++ e também o C ++ 0x estenderá a sintaxe, sendo útil também para contêineres em C ++. Eu não entendo por que você chama isso de estilo ruim?

Se você deseja indicar parâmetros com nomes, pode usar a biblioteca de parâmetros boost , mas isso pode confundir alguém não familiarizado com ela.

Reordenar membros de estrutura é como reordenar parâmetros de funções, essa refatoração pode causar problemas se você não fizer isso com muito cuidado.

E essa sintaxe?

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

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

Acabei de testar em um Microsoft Visual C ++ 2015 e em g ++ 6.0.2. Trabalhando bem.
Você também pode criar uma macro específica se desejar evitar a duplicação do nome da variável.

Para mim, a maneira mais preguiçosa de permitir a inicialização em linha é usar essa 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);

Essa macro cria atributo e método de auto-referência.