Inicjalizacja struktury C ++

Czy można zainicjować struktury w C ++, jak wskazano poniżej

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

Linki tutaj i tutaj wspominają, że można używać tego stylu tylko w C. Jeśli tak, to dlaczego nie jest to możliwe w C ++? Czy istnieje jakiś podstawowy techniczny powód, dla którego nie jest on zaimplementowany w C ++, czy też jest to zła praktyka, aby używać tego stylu. Lubię używać tego sposobu inicjowania, ponieważ moja struktura jest duża, a ten styl daje mi wyraźną czytelność tego, jaka wartość jest przypisana do którego elementu.

Proszę podzielić się ze mną, jeśli istnieją inne sposoby, dzięki którym możemy osiągnąć taką samą czytelność.

Przed opublikowaniem tego pytania zapoznałem się z poniższymi linkami

1. C / C ++ dla AIX
2. C Inicjalizacja struktury za pomocą zmiennej
3. Inicjalizacja struktury statycznej za pomocą znaczników w C ++
4. C ++ 11 Właściwa inicjalizacja struktury

Jeśli chcesz wyjaśnić, co to jest każda wartość inicjalizatora, po prostu podziel ją na wiele wierszy z komentarzem do każdego:

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

Po tym, jak moje pytanie nie przyniosło zadowalającego rezultatu (ponieważ C ++ nie implementuje opartego na tagach init dla struktur), podjąłem sztuczkę, którą tu znalazłem: Czy członkowie struktury C ++ są domyślnie inicjowani na 0?

Dla ciebie oznaczałoby to zrobienie tego:

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

Z pewnością jest to najbliżej tego, co pierwotnie chciałeś (zeruj wszystkie pola oprócz tych, które chcesz zainicjować).

Jak wspomnieli inni, jest to inicjator.

Ta funkcja jest częścią C ++ 20

Identyfikatory pól są rzeczywiście składnią inicjalizacyjną C. W C ++ podaj wartości we właściwej kolejności bez nazw pól. Niestety oznacza to, że musisz podać je wszystkie (w rzeczywistości możesz pominąć końcowe pola o zerowej wartości, a wynik będzie taki sam):

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

Ta funkcja nazywa się wyznaczonymi inicjalizatorami . Jest dodatkiem do standardu C99. Jednak ta funkcja została pominięta w C ++ 11. Zgodnie z językiem programowania C ++, wydanie czwarte, sekcja 44.3.3.2 (Funkcje C niezaadaptowane przez C ++):

Kilka dodatków do C99 (w porównaniu z C89) celowo nie zostało przyjętych w C ++:

[1] Tablice o zmiennej długości (VLA); użyj wektora lub innej formy dynamicznej tablicy

[2] Wyznaczone inicjatory; użyj konstruktorów

Gramatyka C99 ma wyznaczone inicjatory [Patrz ISO / IEC 9899: 2011, Projekt komitetu N1570 - 12 kwietnia 2011 r.]

6.7.9 Inicjalizacja

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

Z drugiej strony C ++ 11 nie ma wyznaczonych inicjatorów [Patrz ISO / IEC 14882: 2011, N3690 Komitet Projekt - 15 maja 2013 r.]

8.5 Inicjatory

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

Aby osiągnąć ten sam efekt, użyj konstruktorów lub list inicjalizacyjnych:

Możesz po prostu zainicjować za pomocą ctor:

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

Możesz nawet spakować rozwiązanie Gui13 do pojedynczej instrukcji inicjalizacji:

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

Oświadczenie: Nie polecam tego stylu

Wiem, że to pytanie jest dość stare, ale znalazłem inny sposób inicjowania, używając constexpr i curry:

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

Ta metoda działa również w przypadku globalnych zmiennych statycznych, a nawet zmiennych constexpr. Jedyną wadą jest zła konserwowalność: za każdym razem, gdy trzeba zainicjować innego członka za pomocą tej metody, wszystkie metody inicjowania członka muszą zostać zmienione.

Być może coś mi tu brakuje, dlaczego nie:

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

Nie jest zaimplementowany w C ++. (także char*ciągi? Mam nadzieję, że nie).

Zwykle, jeśli masz tak wiele parametrów, jest to dość poważny zapach kodu. Ale zamiast tego, dlaczego nie zainicjować wartości struktury, a następnie przypisać każdego członka?

Znalazłem ten sposób na zrobienie tego dla zmiennych globalnych, które nie wymagają modyfikacji oryginalnej definicji struktury:

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

następnie zadeklaruj zmienną nowego typu odziedziczoną z oryginalnego typu struktury i użyj konstruktora do inicjalizacji pól:

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

Jednak nie tak elegancki jak styl C ...

W przypadku zmiennej lokalnej wymaga ona dodatkowej pamięci (this, 0, sizeof (* this)) na początku konstruktora, więc wyraźnie nie jest gorzej, a odpowiedź @ gui13 jest bardziej odpowiednia.

(Zauważ, że „temp_address” jest zmienną typu „temp_address”, jednak ten nowy typ dziedziczy po „adres” i może być używany w każdym miejscu, w którym oczekiwany jest „adres”, więc jest OK.)

Napotkałem dzisiaj podobny problem, w którym mam strukturę, którą chcę wypełnić danymi testowymi, które zostaną przekazane jako argumenty funkcji, którą testuję. Chciałem mieć wektor tych struktur i szukałem metody jednowierszowej do inicjalizacji każdej struktury.

Skończyłem z funkcją konstruktora w strukturze, która, jak sądzę, została również zasugerowana w kilku odpowiedziach na twoje pytanie.

Prawdopodobnie złą praktyką jest, aby argumenty konstruktora miały takie same nazwy jak publiczne zmienne składowe, co wymaga użycia thiswskaźnika. Ktoś może zaproponować edycję, jeśli istnieje lepszy sposób.

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;

Którego użyłem w mojej funkcji testowej do wywołania testowanej funkcji z różnymi argumentami takimi jak ten:

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

Jest to możliwe, ale tylko wtedy, gdy inicjowana struktura jest strukturą POD (zwykłe stare dane). Nie może zawierać żadnych metod, konstruktorów ani nawet wartości domyślnych.

W C ++ inicjatory w stylu C zostały zastąpione konstruktorami, które przez czas kompilacji mogą zapewnić, że wykonywane są tylko prawidłowe inicjalizacje (tj. Po inicjalizacji elementy obiektu są spójne).

Jest to dobra praktyka, ale czasami przydatna jest wstępna inicjalizacja, jak w twoim przykładzie. OOP rozwiązuje to za pomocą klas abstrakcyjnych lub wzorców projektowych .

Moim zdaniem użycie tego bezpiecznego sposobu zabija prostotę, a czasem kompromis w zakresie bezpieczeństwa może być zbyt kosztowny, ponieważ prosty kod nie wymaga skomplikowanego projektu, aby był łatwy w utrzymaniu.

Jako alternatywne rozwiązanie sugeruję zdefiniowanie makr za pomocą lambd, aby uprościć inicjalizację, aby wyglądała prawie jak w stylu 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

Makro ADRES rozwija się do

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

który tworzy i nazywa lambda. Makroparametry są również oddzielone przecinkami, więc musisz umieścić inicjator w nawiasach i wywołać jak

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

Możesz także napisać ogólny inicjalizator makr

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

ale wtedy połączenie jest nieco mniej piękne

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

można jednak łatwo zdefiniować makro ADRES przy użyciu ogólnego makra INIT

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

W GNUC ++ (wydaje się być przestarzały od 2.5, dawno temu :) Zobacz odpowiedzi tutaj: Inicjalizacja struktury C za pomocą etykiet. Działa, ale jak? ), możliwe jest zainicjowanie struktury takiej jak ta:

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

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

Zainspirowany tą naprawdę zgrabną odpowiedzią: ( https://stackoverflow.com/a/49572324/4808079 )

Możesz zrobić zamknięcia Lamba:

// 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 $;
  }();
}

Lub, jeśli chcesz być bardzo fantazyjny

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

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

Wiąże się to z pewnymi wadami, głównie związanymi z niezainicjowanymi członkami. Z tego, co mówią komentarze w odpowiedziach połączonych, kompiluje się wydajnie, chociaż go nie testowałem.

Ogólnie uważam, że to dobre podejście.