Ініціалізація структури C ++

Чи можливо ініціалізувати структури в C ++, як зазначено нижче

struct address {
    int street_no;
    char *street_name;
    char *city;
    char *prov;
    char *postal_code;
};
address temp_address =
    { .city = "Hamilton", .prov = "Ontario" };

Посилання тут і тут згадують, що використовувати цей стиль можна лише в C. Якщо так, чому це неможливо в C ++? Чи є якась основна технічна причина, чому вона не реалізована в C ++, або погана практика використання цього стилю. Мені подобається використовувати такий спосіб ініціалізації, тому що моя структура є великою, і цей стиль дає мені чітку зрозумілість того, яке значення присвоюється члену.

Будь ласка, поділіться зі мною, якщо є інші способи, завдяки яким ми можемо досягти такої самої читабельності.

Я надсилав наступні посилання, перш ніж публікувати це питання

1. C / C ++ для AIX
2. C Ініціалізація структури зі змінною
3. Ініціалізація статичної структури тегами в C ++
4. C ++ 11 Ініціалізація належної структури

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

address temp_addres = {
  0,  // street_no
  nullptr,  // street_name
  "Hamilton",  // city
  "Ontario",  // prov
  nullptr,  // postal_code
};

Після того, як моє запитання не призвело до задоволення результату (оскільки C ++ не реалізує init на основі тегів для структур), я взяв фокус, який я знайшов тут: Чи члени структури C ++ ініціалізовані до 0 за замовчуванням?

Для вас було б зробити це:

address temp_address = {}; // will zero all fields in C++
temp_address.city = "Hamilton";
temp_address.prov = "Ontario";

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

Як згадували інші, це позначається ініціалізатором.

Ця функція входить до C ++ 20

Ідентифікатори поля справді є синтаксисом ініціалізатора C. У C ++ просто наведіть значення у правильному порядку без назв полів. На жаль, це означає, що вам потрібно дати їх усім (насправді ви можете опустити проміжні поля з нульовим значенням, і результат буде однаковим):

address temp_address = { 0, 0, "Hamilton", "Ontario", 0 }; 

Ця функція називається призначеними ініціалізаторами . Це доповнення до стандарту C99. Однак ця функція залишилась поза C ++ 11. Згідно з мовою програмування на C ++, 4-е видання, розділ 44.3.3.2 (Особливості C, не прийняті C ++):

Кілька доповнень до C99 (порівняно з C89) навмисно не було прийнято в C ++:

[1] Масиви змінної довжини (VLA); використовувати векторну чи якусь форму динамічного масиву

[2] Позначені ініціалізатори; використовувати конструктори

Граматика С99 має призначені ініціалізатори [Див. ISO / IEC 9899: 2011, Проект Комітету N1570 - 12 квітня 2011 р.]

6.7.9 Ініціалізація

initializer:
    assignment-expression
    { initializer-list }
    { initializer-list , }
initializer-list:
    designation_opt initializer
    initializer-list , designationopt initializer
designation:
    designator-list =
designator-list:
    designator
    designator-list designator
designator:
    [ constant-expression ]
    . identifier

З іншого боку, C ++ 11 не має призначених ініціалізаторів [Див. ISO / IEC 14882: 2011, Проект Комітету N3690 - 15 травня 2013]

8.5 Ініціалізатори

initializer:
    brace-or-equal-initializer
    ( expression-list )
brace-or-equal-initializer:
    = initializer-clause
    braced-init-list
initializer-clause:
    assignment-expression
    braced-init-list
initializer-list:
    initializer-clause ...opt
    initializer-list , initializer-clause ...opt
braced-init-list:
    { initializer-list ,opt }
    { }

Для досягнення того ж ефекту використовуйте конструктори або списки ініціалізаторів:

Ви можете просто ініціалізувати через ctor:

struct address {
  address() : city("Hamilton"), prov("Ontario") {}
  int street_no;
  char *street_name;
  char *city;
  char *prov;
  char *postal_code;
};

Ви навіть можете упакувати рішення Gui13 в один оператор ініціалізації:

struct address {
                 int street_no;
                 char *street_name;
                 char *city;
                 char *prov;
                 char *postal_code;
               };


address ta = (ta = address(), ta.city = "Hamilton", ta.prov = "Ontario", ta);

Відмова: Я не рекомендую цей стиль

Я знаю, що це питання досить старе, але я знайшов інший спосіб ініціалізації, використовуючи constexpr та currying:

struct mp_struct_t {
    public:
        constexpr mp_struct_t(int member1) : mp_struct_t(member1, 0, 0) {}
        constexpr mp_struct_t(int member1, int member2, int member3) : member1(member1), member2(member2), member3(member3) {}
        constexpr mp_struct_t another_member(int member) { return {member1, member,     member2}; }
        constexpr mp_struct_t yet_another_one(int member) { return {member1, member2, member}; }

    int member1, member2, member3;
};

static mp_struct_t a_struct = mp_struct_t{1}
                           .another_member(2)
                           .yet_another_one(3);

Цей метод також працює для глобальних статичних змінних і навіть для contexpr. Єдиним недоліком є ​​погана ремонтопридатність: Кожен раз, коли інший член повинен бути ініціалізований за допомогою цього методу, всі методи ініціалізації членів повинні бути змінені.

Я, можливо, щось тут не вистачає, чому б ні:

#include <cstdio>    
struct Group {
    int x;
    int y;
    const char* s;
};

int main() 
{  
  Group group {
    .x = 1, 
    .y = 2, 
    .s = "Hello it works"
  };
  printf("%d, %d, %s", group.x, group.y, group.s);
}

Це не реалізовано в C ++. (також char*рядки? Сподіваюсь, що ні).

Зазвичай, якщо у вас стільки параметрів, це досить серйозний запах коду. Але натомість, чому б не просто ініціалізувати структуру і не призначити кожного члена?

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

struct address {
             int street_no;
             char *street_name;
             char *city;
             char *prov;
             char *postal_code;
           };

потім оголосити змінну нового типу, успадковану від початкового типу структура та використати конструктор для ініціалізації полів:

struct temp_address : address { temp_address() { 
    city = "Hamilton"; 
    prov = "Ontario"; 
} } temp_address;

Не настільки елегантний, як стиль C, хоча ...

Для локальної змінної вона потребує додаткового набору (це, 0, sizeof (* це)) на початку конструктора, тому це явно не гірше, і відповідь @ gui13 є більш доречною.

(Зауважте, що 'temp_address' є змінною типу 'temp_address', однак цей новий тип успадковується від 'address' і може використовуватися в будь-якому місці, де очікується 'address', тому це нормально.)

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

Я закінчила функцію конструктора в структурі, яка, на мою думку, також була запропонована в кількох відповідях на ваше запитання.

Мабуть, погана практика, щоб аргументи конструктору мали такі самі назви, як і загальнодоступні змінні, що вимагає використання thisвказівника. Хтось може запропонувати редагувати, якщо є кращий спосіб.

typedef struct testdatum_s {
    public:
    std::string argument1;
    std::string argument2;
    std::string argument3;
    std::string argument4;
    int count;

    testdatum_s (
        std::string argument1,
        std::string argument2,
        std::string argument3,
        std::string argument4,
        int count)
    {
        this->rotation = argument1;
        this->tstamp = argument2;
        this->auth = argument3;
        this->answer = argument4;
        this->count = count;
    }

} testdatum;

Який я використовував у своїй тестовій функції для виклику функції, що тестується, за допомогою різних аргументів на кшталт цього:

std::vector<testdatum> testdata;

testdata.push_back(testdatum("val11", "val12", "val13", "val14", 5));
testdata.push_back(testdatum("val21", "val22", "val23", "val24", 1));
testdata.push_back(testdatum("val31", "val32", "val33", "val34", 7));

for (std::vector<testdatum>::iterator i = testdata.begin(); i != testdata.end(); ++i) {
    function_in_test(i->argument1, i->argument2, i->argument3, i->argument4m i->count);
}

Це можливо, але тільки якщо структура, яку ви ініціалізуєте, - це структура POD (звичайні старі дані). Він не може містити жодних методів, конструкторів або навіть значень за замовчуванням.

У C ++ ініціалізатори стилю C були замінені конструкторами, які за час компіляції можуть забезпечити виконання тільки дійсних ініціалізацій (тобто після ініціалізації члени об'єкта є послідовними).

Це хороша практика, але іноді попередня ініціалізація зручна, як у вашому прикладі. OOP вирішує це за допомогою абстрактних класів або креативних моделей дизайну .

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

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

struct address {
  int street_no;
  const char *street_name;
  const char *city;
  const char *prov;
  const char *postal_code;
};
#define ADDRESS_OPEN [] { address _={};
#define ADDRESS_CLOSE ; return _; }()
#define ADDRESS(x) ADDRESS_OPEN x ADDRESS_CLOSE

Макрос АДРЕС розширюється до

[] { address _={}; /* definition... */ ; return _; }()

що творить і називає лямбда. Параметри макросу також розділені комами, тому потрібно поставити ініціалізатор в дужки і викликати подібні

address temp_address = ADDRESS(( _.city = "Hamilton", _.prov = "Ontario" ));

Ви також можете написати генералізований ініціалізатор макросів

#define INIT_OPEN(type) [] { type _={};
#define INIT_CLOSE ; return _; }()
#define INIT(type,x) INIT_OPEN(type) x INIT_CLOSE

але тоді дзвінок трохи менш гарний

address temp_address = INIT(address,( _.city = "Hamilton", _.prov = "Ontario" ));

однак ви можете визначити макрос АДРЕС за допомогою загального макроса INIT легко

#define ADDRESS(x) INIT(address,x)

У GNUC ++ (здається, застаріла з 2.5, давно) :) Дивіться відповіді тут: Ініціалізація структури C за допомогою міток. Це працює, але як? ), можна ініціалізувати структуру, як це:

struct inventory_item {
    int bananas;
    int apples;
    int pineapples;
};

inventory_item first_item = {
    bananas: 2,
    apples: 49,
    pineapples: 4
};

Натхненний цією справді акуратною відповіддю: ( https://stackoverflow.com/a/49572324/4808079 )

Ви можете робити закриття з ламби:

// Nobody wants to remember the order of these things
struct SomeBigStruct {
  int min = 1;
  int mean = 3 ;
  int mode = 5;
  int max = 10;
  string name;
  string nickname;
  ... // the list goes on
}

.

class SomeClass {
  static const inline SomeBigStruct voiceAmps = []{
    ModulationTarget $ {};
    $.min = 0;  
    $.nickname = "Bobby";
    $.bloodtype = "O-";
    return $;
  }();
}

Або, якщо ви хочете бути дуже фантазійними

#define DesignatedInit(T, ...)\
  []{ T ${}; __VA_ARGS__; return $; }()

class SomeClass {
  static const inline SomeBigStruct voiceAmps = DesignatedInit(
    ModulationTarget,
    $.min = 0,
    $.nickname = "Bobby",
    $.bloodtype = "O-",
  );
}

У цьому є деякі недоліки, які стосуються переважно неініціалізованих членів. З тих, що кажуть відповіді на коментарі, вона збирається ефективно, хоча я її не перевіряв.

В цілому, я просто думаю, що це акуратний підхід.