Зручна ініціалізація C ++

Я намагаюся знайти зручний спосіб ініціалізувати структури "pod" C ++. Тепер розглянемо таку структуру:

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

Якщо я хочу зручно ініціалізувати це на C (!), Я можу просто написати:

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

Зауважте, що я хочу явно уникати наступних позначень, тому що це вражає мене так, як мене роблять зламати шию, якщо я в майбутньому щось зміню в структурі:

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

Щоб досягти такого ж (або принаймні подібного) в C ++, як у /* A */прикладі, мені доведеться реалізувати ідіотичний конструктор:

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

Що добре для киплячої води, але не підходить для ледачих людей (лінь - це добра справа, правда?). Крім того, це майже так само погано, як /* B */приклад, оскільки він не чітко вказує, яке значення йде для якого члена.

Отже, моє питання полягає в основному, як я можу досягти чогось подібного /* A */або кращого в C ++? Як варіант, мені було б добре з поясненням, чому я не хочу цього робити (тобто чому моя психічна парадигма погана).

EDIT

Під зручним , я маю на увазі також ремонтопридатне та непотрібне .

Зазначені ініціалізації будуть підтримуватися в c ++ 2a, але вам не доведеться чекати, оскільки вони офіційно підтримуються GCC, Clang та 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

Оскільки style Aце не дозволено в C ++, і ви не хочете, style Bяк тоді використовувати style BX:

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

Принаймні допомогти в якійсь мірі.

Ви можете використовувати лямбда:

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

Більше інформації про цю ідіому можна знайти в блозі Herb Sutter .

Витягніть домішки до функцій, які описують їх (базовий рефакторинг):

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

Я знаю, що стиль дуже близький до того, який ви не хотіли використовувати, але він дозволяє простіше замінити постійні значення, а також пояснити їх (таким чином, не потрібно редагувати коментарі), якщо вони коли-небудь змінюють це.

Інша річ, яку ви можете зробити (оскільки ви ліниві) - це зробити конструктор вбудованим, тому вам не доведеться набирати стільки (видаляючи "Foobar ::", так і витрачаючи час на перемикання між файлом h і cpp):

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

Ваше запитання дещо складне, оскільки навіть функція:

static FooBar MakeFooBar(int foo, float bar);

може називатися:

FooBar fb = MakeFooBar(3.4, 5);

через правила просування та перетворення для вбудованих числових типів. (C ніколи не був дуже сильно набраний)

У C ++ те, що ви хочете, можна досягти, хоча за допомогою шаблонів і статичних тверджень:

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

В C ви можете назвати параметри, але далі ви ніколи не дістанетесь.

З іншого боку, якщо все, що ви хочете, називається параметрами, то ви пишете безліч громіздких кодів:

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

А ви можете поперчити в захисті просування типу, якщо хочете.

Багато Frontends C ++ компіляторів (включаючи GCC та clang) розуміють синтаксис ініціалізатора C. Якщо можете, просто використовуйте цей метод.

Ще один спосіб у 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);

Варіант D:

FooBar FooBarMake(int foo, float bar)

Юридичний C, юридичний C ++. Легко оптимізується для POD. Звичайно, ніяких названих аргументів немає, але це як у всіх C ++. Якщо ви хочете назвати аргументи, об'єктив C повинен бути кращим вибором.

Варіант E:

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

Юридичний C, юридичний C ++. Названі аргументи.

Я знаю, що це питання давнє, але є спосіб вирішити це питання, поки C ++ 20 нарешті не переведе цю функцію з C на C ++. Що ви можете зробити для вирішення цього питання - це використовувати макроси препроцесора з static_asserts, щоб перевірити, чи ваша ініціалізація є дійсною. (Я знаю, що макроси, як правило, погані, але тут я не бачу іншого способу.) Дивіться приклад коду нижче:

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

Тоді, коли у вас є структура з атрибутами const, ви можете це зробити:

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

Це трохи незручно, тому що вам потрібні макроси для кожної можливої ​​кількості атрибутів, і вам потрібно повторити тип і ім'я свого примірника у виклику макросу. Також ви не можете використовувати макрос у зворотному операторі, тому що твердження з’являються після ініціалізації.

Але це все-таки вирішує вашу проблему: Коли ви зміните структуру, виклик буде невдалим під час компіляції.

Якщо ви використовуєте C ++ 17, ви навіть можете зробити ці макроси більш суворими, форсуючи ті самі типи, наприклад:

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

Шлях /* B */добре в C ++, також C ++ 0x збирається розширити синтаксис, тому він корисний і для контейнерів C ++. Я не розумію, чому ви називаєте це поганим стилем?

Якщо ви хочете вказати параметри з іменами, ви можете використовувати бібліотеку параметрів boost , але це може збентежити когось незнайомого з ним.

Упорядкування членів структури - це як переупорядкування параметрів функції, таке рефакторинг може спричинити проблеми, якщо ви не будете робити це дуже обережно.

Що з цим синтаксисом?

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

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

Щойно перевірена на Microsoft Visual C ++ 2015 та на g ++ 6.0.2. Працює нормально.
Ви можете зробити певний макрос також, якщо хочете уникнути дублювання імені змінної.

Для мене самий ледачий спосіб дозволити вбудовану ініціалізацію - це використовувати цей макрос.

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

Цей макрос створює атрибут та метод самостійного посилання.