Como inicializar uma estrutura de acordo com os padrões da linguagem de programação C

Eu quero inicializar um elemento struct, dividido em declaração e inicialização. Isto é o que eu tenho:

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

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

É assim que se declara e inicializa uma variável local de MY_TYPE acordo com os padrões da linguagem de programação C (C89, C90, C99, C11, etc.)? Ou há algo melhor ou pelo menos funcionando?

Atualização Acabei tendo um elemento de inicialização estático, onde defini todos os subelementos de acordo com minhas necessidades.

No (ANSI) C99, você pode usar um inicializador designado para inicializar uma estrutura:

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

Editar: Outros membros são inicializados como zero: "Membros de campo omitidos são inicializados implicitamente da mesma forma que objetos que têm duração de armazenamento estático". ( https://gcc.gnu.org/onlinedocs/gcc/Designated-Inits.html )

Você pode fazer isso com um literal composto . De acordo com essa página, ele funciona em C99 (que também conta como 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 };

As designações nos inicializadores são opcionais; você também pode escrever:

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

Vejo que você já recebeu uma resposta sobre o ANSI C 99, portanto, discutirei o ANSI C 89. O ANSI C 89 permite que você inicialize uma estrutura dessa maneira:

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

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

É importante lembrar que, no momento em que você inicializa até um objeto / variável na estrutura, todas as outras variáveis ​​serão inicializadas com o valor padrão.

Se você não inicializar os valores em sua estrutura, todas as variáveis ​​conterão "valores de lixo".

Boa sorte!

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

faria bem em C99

Você quase conseguiu ...

MY_TYPE a = { true,15,0.123 };

A pesquisa rápida em 'struct initialize c' mostra-me isto

A norma de linguagem de programação C ISO / IEC 9899: 1999 (comumente conhecida como C99) permite usar um inicializador designado para inicializar membros de uma estrutura ou união da seguinte maneira:

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

É definido na paragraph 7seção 6.7.8 Initializationda norma ISO / IEC 9899: 1999 como:

Se um designador tiver o formulário
. identificador
, o objeto atual (definido abaixo) deve ter estrutura ou tipo de união e o identificador deve ser o nome de um membro desse tipo.

Observe que paragraph 9na mesma seção afirma que:

Exceto quando indicado explicitamente em contrário, para os fins desta subcláusula, os membros não nomeados dos objetos de estrutura e tipo de união não participam da inicialização. Membros sem nome de objetos de estrutura têm valor indeterminado, mesmo após a inicialização.

Na implementação do GNU GCC, no entanto, os membros omitidos são inicializados como zero ou valor apropriado para o tipo zero. Conforme indicado na seção 6.27 Inicializadores designados da documentação do GNU GCC:

Membros de campo omitidos são inicializados implicitamente da mesma forma que objetos que têm duração de armazenamento estático.

O compilador do Microsoft Visual C ++ deve oferecer suporte a inicializadores designados desde a versão 2013, de acordo com o post oficial do blog C ++ Conformance Roadmap . O artigo Parágrafo Initializing unions and structsdo inicializador na documentação do MSDN Visual Studio sugere que membros sem nome inicializassem com valores apropriados de zero-zero, de maneira semelhante ao GNU GCC.

A norma ISO / IEC 9899: 2011 (comumente conhecida como C11) que substituiu a ISO / IEC 9899: 1999 mantém os inicializadores designados na seção 6.7.9 Initialization. Ele também mantém paragraph 9inalterado.

O novo padrão ISO / IEC 9899: 2018 (conhecido como C18) que substituiu o ISO / IEC 9899: 2011 mantém os inicializadores designados na seção 6.7.9 Initialization. Ele também mantém paragraph 9inalterado.

como Ron Nuni disse:

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

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

Uma coisa importante a lembrar: no momento em que você inicializa até um objeto / variável na estrutura, todas as outras variáveis ​​serão inicializadas com o valor padrão.

Se você não inicializar os valores em sua estrutura (por exemplo, se você apenas declarar essa variável), todos variable.membersconterão "valores de lixo", apenas se a declaração for local!

Se a declaração for global ou estática (como neste caso), todos os não inicializados variable.membersserão inicializados automaticamente para:

• 0 para números inteiros e ponto flutuante
• '\0'para char(é claro que isso é exatamente o mesmo que 0e charé um tipo inteiro)
• NULL para ponteiros.

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

Se a MS não tiver atualizado para C99, MY_TYPE a = {true, 15,0.123};

Encontrei outra maneira de inicializar estruturas.

A estrutura:

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

Inicialização:

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

De acordo com a documentação do GCC, essa sintaxe é obsoleta desde o GCC 2.5 .

Eu não gostei de nenhuma dessas respostas, então criei as minhas. Não sei se isso é ANSI C ou não, é apenas o GCC 4.2.1 no modo padrão. Como nunca me lembro do bracketing, começo com um subconjunto dos meus dados e luto com as mensagens de erro do compilador até que ele seja encerrado. A legibilidade é minha primeira prioridade.

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

Os dados podem iniciar a vida como um arquivo delimitado por tabulação que você substitui para massagear outra coisa. Sim, isso é material do Debian. Portanto, um par externo de {} (indicando a matriz) e outro par para cada estrutura interna. Com vírgulas entre. Colocar as coisas em um cabeçalho não é estritamente necessário, mas eu tenho cerca de 50 itens na minha estrutura, então eu os quero em um arquivo separado, para manter a bagunça fora do meu código e para facilitar a substituição.

A estrutura em C pode ser declarada e inicializada assim:

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

Eu li a documentação do Microsoft Visual Studio 2015 para inicializar tipos agregados ainda, todas as formas de inicialização com {...}são explicadas lá, mas a inicialização com ponto, denominada '' designador '' não é mencionada lá. Também não funciona.

O capítulo C.7 da norma C99 6.7.8 Inicialização explica a possibilidade de designadores, mas, na minha opinião, não é realmente claro para estruturas complexas. O padrão C99 como pdf .

Na minha opinião, pode ser melhor

1. Use a = {0};inicialização para todos os dados estáticos. É menos esforço para o código da máquina.

2. Use macros para inicializar, por exemplo

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

A macro pode ser adaptada, sua lista de argumentos pode ser independente do conteúdo da estrutura alterado. É adequado se menos elementos forem inicializados. Também é adequado para estrutura aninhada. 3. Um formulário simples é: Inicialize em uma sub-rotina:

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

Essa rotina se parece com ObjectOriented em C. Use thiz, não thispara compilá-la com C ++ também!

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

Eu tenho procurado uma boa maneira de inicializar minha estrutura, e eu tenho que usar o abaixo (C99). Isso me permite inicializar uma única estrutura ou uma matriz de estruturas da mesma maneira que os tipos simples.

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

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

Isso pode ser usado no código como:

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 */