Wygodna inicjalizacja struktury w C ++

Próbuję znaleźć wygodny sposób na zainicjowanie struktur „pod” C ++. Rozważmy teraz następującą strukturę:

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

Jeśli chcę wygodnie zainicjalizować to w C (!), Mógłbym po prostu napisać:

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

Zauważ, że chcę wyraźnie uniknąć następującego zapisu, ponieważ wydaje mi się, że skręca mi kark, jeśli zmienię cokolwiek w strukturze w przyszłości:

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

Aby osiągnąć to samo (lub przynajmniej podobne) w C ++ jak w /* A */przykładzie, musiałbym zaimplementować idiotycznego konstruktora:

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

Co jest dobre do gotowania wody, ale nieodpowiednie dla leniwych (lenistwo to dobra rzecz, prawda?). Ponadto jest tak samo zły jak /* B */przykład, ponieważ nie określa wyraźnie, która wartość trafia do którego elementu.

Więc moje pytanie brzmi: jak mogę osiągnąć coś podobnego /* A */lub lepszego w C ++? Alternatywnie, wystarczyłoby mi wyjaśnienie, dlaczego nie powinienem tego robić (tj. Dlaczego mój paradygmat mentalny jest zły).

EDYTOWAĆ

Przez wygodny mam na myśli również konserwowalne i nienadmiarowe .

Wyznaczone inicjalizacje będą obsługiwane w c ++ 2a, ale nie musisz czekać, ponieważ są oficjalnie obsługiwane przez GCC, Clang i 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

Ponieważ style Anie jest to dozwolone w C ++ i nie chcesz, style Bto co powiesz na użycie style BX:

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

Przynajmniej w jakimś stopniu pomóc.

Możesz użyć lambdy:

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

Więcej informacji na temat tego idiomu można znaleźć na blogu Herba Suttera .

Wyodrębnij składowe do funkcji, które je opisują (podstawowa refaktoryzacja):

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

Wiem, że styl jest bardzo zbliżony do tego, którego nie chciałeś używać, ale umożliwia łatwiejszą zamianę stałych wartości, a także ich wyjaśnienie (dzięki czemu nie trzeba edytować komentarzy), jeśli kiedykolwiek się zmienią.

Inną rzeczą, którą możesz zrobić (ponieważ jesteś leniwy), jest wstawienie konstruktora w tekście, więc nie musisz wpisywać tak dużo (usunięcie "Foobar ::" i czasu spędzonego na przełączaniu między plikiem h i cpp):

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

Twoje pytanie jest nieco trudne, ponieważ nawet funkcja:

static FooBar MakeFooBar(int foo, float bar);

można nazwać:

FooBar fb = MakeFooBar(3.4, 5);

ze względu na zasady promocji i konwersji dla wbudowanych typów liczbowych. (C nigdy nie było naprawdę mocno wpisane)

W C ++ to, co chcesz, jest osiągalne, chociaż za pomocą szablonów i statycznych asercji:

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

W C możesz nazwać parametry, ale nigdy nie przejdziesz dalej.

Z drugiej strony, jeśli chcesz tylko nazwać parametry, piszesz dużo nieporęcznego kodu:

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

I jeśli chcesz, możesz zabezpieczyć się przed awansem typu.

Wiele nakładek C ++ kompilatorów (w tym GCC i clang) rozumie składnię inicjalizatora C. Jeśli możesz, po prostu użyj tej metody.

Jeszcze innym sposobem w C ++ jest

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

Opcja D:

FooBar FooBarMake(int foo, float bar)

Prawne C, prawne C ++. Łatwa optymalizacja dla POD. Oczywiście nie ma nazwanych argumentów, ale to jest jak we wszystkich C ++. Jeśli potrzebujesz nazwanych argumentów, lepszym wyborem powinien być Cel C.

Opcja E:

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

Prawne C, prawne C ++. Nazwane argumenty.

Wiem, że to pytanie jest stare, ale istnieje sposób na rozwiązanie tego problemu, dopóki C ++ 20 w końcu nie przeniesie tę funkcję z C do C ++. Aby rozwiązać ten problem, użyj makr preprocesora z static_asserts, aby sprawdzić, czy inicjalizacja jest prawidłowa. (Wiem, że makra są generalnie złe, ale tutaj nie widzę innego sposobu.) Zobacz przykładowy kod poniżej:

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

Następnie, gdy masz strukturę z atrybutami const, możesz zrobić to:

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

Jest to trochę niewygodne, ponieważ potrzebujesz makr dla każdej możliwej liczby atrybutów i musisz powtórzyć typ i nazwę swojej instancji w wywołaniu makra. Nie można również użyć makra w instrukcji return, ponieważ potwierdzenia pojawiają się po inicjalizacji.

Ale to rozwiązuje twój problem: kiedy zmienisz strukturę, wywołanie zakończy się niepowodzeniem w czasie kompilacji.

Jeśli używasz C ++ 17, możesz nawet uczynić te makra bardziej rygorystycznymi, wymuszając te same typy, np .:

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

Droga /* B */ jest w porządku w C ++, również C ++ 0x rozszerzy składnię, więc jest przydatny również dla kontenerów C ++. Nie rozumiem, dlaczego nazywasz to złym stylem?

Jeśli chcesz oznaczyć parametry nazwami, możesz użyć biblioteki parametrów boost , ale może to zmylić kogoś nieznającego się na niej.

Zmiana kolejności elementów strukturalnych jest podobna do zmiany kolejności parametrów funkcji. Taka refaktoryzacja może powodować problemy, jeśli nie zrobisz tego bardzo ostrożnie.

A co z tą składnią?

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

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

Właśnie przetestowano na Microsoft Visual C ++ 2015 i g ++ 6.0.2. Działa OK.
Możesz utworzyć określone makro również, jeśli chcesz uniknąć powielania nazwy zmiennej.

Dla mnie najbardziej leniwym sposobem na umożliwienie inicjalizacji inline jest użycie tego makra.

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

To makro tworzy atrybut i metodę odniesienia do siebie.