Jak zainicjować strukturę zgodnie ze standardami języka programowania C.

Chcę zainicjować element struct, podzielić na deklarację i inicjalizację. Oto co mam:

typedef struct MY_TYPE {
  bool flag;
  short int value;
  double stuff;
} MY_TYPE;

void function(void) {
  MY_TYPE a;
  ...
  a = { true, 15, 0.123 }
}

Czy to jest sposób na zadeklarowanie i zainicjowanie zmiennej lokalnej MY_TYPEzgodnie ze standardami języka programowania C (C89, C90, C99, C11 itd.)? A może jest coś lepszego lub przynajmniej działa?

Aktualizacja Skończyłem z statycznym elementem inicjującym, w którym ustawiam każdy podelement zgodnie z moimi potrzebami.

W (ANSI) C99 możesz użyć wyznaczonego inicjatora do zainicjowania struktury:

MY_TYPE a = { .flag = true, .value = 123, .stuff = 0.456 };

Edycja: Inne elementy są inicjowane jako zero: „Pominięte elementy pola są domyślnie inicjowane tak samo jak obiekty o statycznym czasie przechowywania.” ( https://gcc.gnu.org/onlinedocs/gcc/Designated-Inits.html )

Możesz to zrobić za pomocą złożonego literału . Według tej strony działa w C99 (który również liczy się jako ANSI C ).

MY_TYPE a;

a = (MY_TYPE) { .flag = true, .value = 123, .stuff = 0.456 };
...
a = (MY_TYPE) { .value = 234, .stuff = 1.234, .flag = false };

Oznaczenia w inicjalizatorach są opcjonalne; możesz także napisać:

a = (MY_TYPE) { true,  123, 0.456 };
...
a = (MY_TYPE) { false, 234, 1.234 };

Widzę, że już otrzymałeś odpowiedź na temat ANSI C 99, więc rzucę kość o ANSI C 89. ANSI C 89 pozwala na zainicjowanie struktury w ten sposób:

typedef struct Item {
    int a;
    float b;
    char* name;
} Item;

int main(void) {
    Item item = { 5, 2.2, "George" };
    return 0;
}

Ważną rzeczą do zapamiętania, w momencie inicjalizacji choćby jednego obiektu / zmiennej w strukturze, wszystkie pozostałe zmienne zostaną zainicjalizowane do wartości domyślnej.

Jeśli nie zainicjujesz wartości w swojej strukturze, wszystkie zmienne będą zawierały „wartości śmieci”.

Powodzenia!

a = (MYTYPE){ true, 15, 0.123 };

sprawdziłby się w C99

Już prawie masz ...

MY_TYPE a = { true,15,0.123 };

Szybkie wyszukiwanie w „struct initialize c” pokazuje mi to

Norma języka programowania C ISO / IEC 9899: 1999 (powszechnie znana jako C99) pozwala na użycie wyznaczonego inicjatora do inicjowania elementów struktury lub unii w następujący sposób:

MY_TYPE a = { .stuff = 0.456, .flag = true, .value = 123 };

Jest zdefiniowany w paragraph 7sekcji6.7.8 Initialization normy ISO / IEC 9899: 1999 jako:

Jeśli desygnator ma formularz
. identyfikator
wówczas bieżący obiekt (zdefiniowany poniżej) będzie miał strukturę lub typ unii, a identyfikator będzie nazwą członka tego typu.

Należy zauważyć, że paragraph 9w tej samej sekcji stwierdzono, że:

O ile wyraźnie nie zaznaczono inaczej, dla celów niniejszego podrozdziału nienazwani członkowie obiektów o strukturze i typie unii nie uczestniczą w inicjalizacji. Nienazwane elementy obiektów struktury mają nieokreśloną wartość nawet po inicjalizacji.

Jednak w implementacji GNU GCC pominięte elementy są inicjowane jako wartość odpowiednia dla typu zero lub podobna do zera. Jak stwierdzono w sekcji 6.27 Wyznaczone inicjatory dokumentacji GNU GCC:

Pominięte elementy pola są domyślnie inicjowane tak samo, jak obiekty o statycznym czasie przechowywania.

Kompilator Microsoft Visual C ++ powinien obsługiwać wyznaczone inicjatory od wersji 2013, zgodnie z oficjalnym blogiem C ++ Conformance Roadmap . Akapit artykułu Initializing unions and structso inicjalizatorach w dokumentacji MSDN Visual Studio sugeruje, że nienazwani członkowie inicjują się do odpowiednich zerowych wartości, podobnie jak GNU GCC.

Norma ISO / IEC 9899: 2011 (powszechnie znana jako C11), która zastąpiła normę ISO / IEC 9899: 1999, zachowuje wyznaczone inicjatory zgodnie z sekcją 6.7.9 Initialization. Zachowuje również paragraph 9niezmienione.

Nowa norma ISO / IEC 9899: 2018 (powszechnie znana jako C18), która zastąpiła ISO / IEC 9899: 2011, zachowuje wyznaczone inicjatory w sekcji 6.7.9 Initialization. Zachowuje również paragraph 9niezmienione.

jak powiedział Ron Nuni:

typedef struct Item {
    int a;
    float b;
    char* name;
} Item;

int main(void) {
    Item item = {5, 2.2, "George"};
    return 0;
}

Ważną rzecz do zapamiętania: w momencie inicjalizacji nawet jednego obiektu / zmiennej w strukturze, wszystkie pozostałe zmienne zostaną zainicjalizowane do wartości domyślnej.

Jeśli nie zainicjujesz wartości w swojej strukturze (tj. Jeśli po prostu zadeklarujesz tę zmienną), wszystkie variable.membersbędą zawierały „wartości śmieci”, tylko jeśli deklaracja jest lokalna!

Jeśli deklaracja jest globalna lub statyczna (jak w tym przypadku), wszystkie niezainicjowane variable.memberszostaną automatycznie zainicjowane, aby:

• 0 dla liczb całkowitych i zmiennoprzecinkowych
• '\0'dla char(oczywiście jest to tak samo jak 0ichar jest liczbą całkowitą)
• NULL dla wskaźników.

void function(void) {
  MY_TYPE a;
  a.flag = true;
  a.value = 15;
  a.stuff = 0.123;
}

Jeśli MS nie zaktualizowało się do C99, MY_TYPE a = {true, 15,0.123};

Znalazłem inny sposób inicjowania struktur.

Struktura:

typedef struct test {
    int num;
    char* str;
} test;

Inicjalizacja:

test tt = {
    num: 42,
    str: "nice"
};

Zgodnie z dokumentacją GCC ta składnia jest przestarzała od GCC 2.5 .

Nie podobała mi się żadna z tych odpowiedzi, więc zrobiłem własną. Nie wiem, czy to ANSI C, czy nie, to tylko GCC 4.2.1 w trybie domyślnym. Nigdy nie pamiętam braketingu, więc zaczynam od podzbioru moich danych i walczę z komunikatami o błędach kompilatora, dopóki się nie zamknie. Czytelność jest moim pierwszym priorytetem.

    // in a header:
    typedef unsigned char uchar;

    struct fields {
      uchar num;
      uchar lbl[35];
    };

    // in an actual c file (I have 2 in this case)
    struct fields labels[] = {
      {0,"Package"},
      {1,"Version"},
      {2,"Apport"},
      {3,"Architecture"},
      {4,"Bugs"},
      {5,"Description-md5"},
      {6,"Essential"},
      {7,"Filename"},
      {8,"Ghc-Package"},
      {9,"Gstreamer-Version"},
      {10,"Homepage"},
      {11,"Installed-Size"},
      {12,"MD5sum"},
      {13,"Maintainer"},
      {14,"Modaliases"},
      {15,"Multi-Arch"},
      {16,"Npp-Description"},
      {17,"Npp-File"},
      {18,"Npp-Name"},
      {19,"Origin"}
    };

Dane mogą rozpoczynać życie jako plik rozdzielany tabulatorami, który należy przeszukiwać i zamieniać w coś innego. Tak, to są rzeczy Debiana. Tak więc jedna zewnętrzna para {} (wskazująca tablicę), a następnie kolejna para dla każdej struktury wewnątrz. Z przecinkami między. Umieszczanie rzeczy w nagłówku nie jest absolutnie konieczne, ale mam około 50 elementów w mojej strukturze, więc chcę je w osobnym pliku, zarówno po to, aby nie bałagan w moim kodzie, więc łatwiej jest go zamienić.

Strukturę w C można zadeklarować i zainicjować w następujący sposób:

typedef struct book
{
    char title[10];
    char author[10];
    float price;
} book;

int main() {
    book b1={"DS", "Ajay", 250.0};

    printf("%s \t %s \t %f", b1.title, b1.author, b1.price);

    return 0;
}

Przeczytałem już dokumentację Microsoft Visual Studio 2015 dotyczącą inicjowania typów agregatów , wszystkie formy inicjowania{...} są tam wyjaśnione, ale nie ma tam mowy o inicjowaniu za pomocą kropki o nazwie „desygnator”. To też nie działa.

Standardowy C99 rozdział 6.7.8 Inicjalizacja wyjaśnia możliwości desygnatorów, ale moim zdaniem nie jest tak naprawdę jasne dla złożonych struktur. Standard C99 jako pdf .

Moim zdaniem może być lepiej

1. Użyj = {0}; -inicjalizacji dla wszystkich danych statycznych. Kod maszynowy wymaga mniej wysiłku.

2. Na przykład użyj makr do inicjalizacji

   typedef MyStruct_t{ int x, int a, int b; } MyStruct; define INIT_MyStruct(A,B) { 0, A, B}

Makro można dostosować, jego lista argumentów może być niezależna od zmienionej zawartości struktury. Właściwe jest, aby zainicjować mniej elementów. Jest także odpowiedni dla zagnieżdżonej struktury. 3. Prosty formularz to: Zainicjuj w podprogramie:

void init_MyStruct(MyStruct* thiz, int a, int b) {
  thiz->a = a; thiz->b = b; }

Ta procedura wygląda jak ObjectOriented w C. Użyj thiz, nie thiskompiluj jej również w C ++!

MyStruct data = {0}; //all is zero!
init_MyStruct(&data, 3, 456);

Szukałem fajnego sposobu na zainicjowanie mojej struktury i muszę skorzystać z poniższego (C99). To pozwala mi zainicjować pojedynczą strukturę lub tablicę struktur w taki sam sposób, jak zwykłe typy.

typedef struct {
    char *str;
    size_t len;
    jsmntok_t *tok;
    int tsz;
} jsmn_ts;

#define jsmn_ts_default (jsmn_ts){NULL, 0, NULL, 0}

Można to wykorzystać w kodzie jako:

jsmn_ts mydata = jsmn_ts_default; /* initialization of a single struct */

jsmn_ts myarray[10] = {jsmn_ts_default, jsmn_ts_default}; /* initialization of
                                                    first 2 structs in the array */