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

你差不多懂了……

MY_TYPE a = { true, 15, 0.123 };

快速搜索'struct initialize c'显示了这一点

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

会在C99做得很好吗

你可以用复合字面量来做。根据该页面，它在C99(也算作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 };

初始化式中的指定是可选的;你也可以这样写:

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

在(ANSI) C99中，您可以使用指定的初始化式来初始化结构:

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

其他成员初始化为零:“省略的字段成员隐式初始化，与具有静态存储持续时间的对象相同。”(https://gcc.gnu.org/onlinedocs/gcc/Designated-Inits.html)

我知道你已经收到了关于ANSI c99的答复，所以我要对ANSI c89说一句。 ANSI C 89允许你这样初始化一个结构:

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

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

需要记住的一件重要的事情是，当你初始化结构中的一个对象/变量时，它的所有其他变量都将初始化为默认值。

如果你不初始化结构中的值，所有变量都将包含“垃圾值”。

正如罗恩·努尼所说:

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

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

需要记住的一件重要的事情是:当你初始化结构中的一个对象/变量时，它的所有其他变量将被初始化为默认值。

如果你不初始化你的结构中的值(即，如果你只是声明那个变量)，所有变量。成员将包含“垃圾值”，只有当声明是本地的!

如果声明是全局的或静态的(如本例)，则所有未初始化的变量。成员将自动初始化为:

0表示整数和浮点数 '\0'表示char(当然这和0是一样的，而且char是整数类型) 指针为NULL。

如果MS没有更新到C99, MY_TYPE a = {true,15,0.123};

我找到了另一种初始化结构的方法。

结构:

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

初始化:

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

根据GCC的文档，这个语法从GCC 2.5开始就已经过时了。

这些答案我都不喜欢，所以我自己编了一个。我不知道这是否是ANSI C，它只是默认模式下的GCC 4.2.1。我从来不记得括号，所以我从我的数据子集开始，并与编译器错误消息做斗争，直到它关闭。可读性是我的首要任务。

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

数据一开始可能是一个以制表符分隔的文件，您可以搜索-替换它以将其转换为其他文件。是的，这是Debian的东西。因此，一个外部的{}对(表示数组)，然后是内部每个结构的另一对。中间有逗号。把东西放在一个头并不是严格必要的，但我在我的结构中有大约50项，所以我想把它们放在一个单独的文件中，既保持混乱的代码，所以更容易替换。

C编程语言标准ISO/IEC 9899:1999(通常称为C99)允许使用指定的初始化式来初始化结构或联合的成员，如下所示:

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

ISO/IEC 9899:1999标准第6.7.8节初始化第7段定义为:

如果指示符具有该形式 ． 标识符 那么当前对象(定义如下)将具有结构类型或联合类型，标识符将是该类型成员的名称。

注意，同一节第9段规定:

除非另有明确说明，为了本小节的目的，结构类型和联合类型对象的未命名成员不参与初始化。结构对象的未命名成员即使在初始化之后也具有不确定的值。

然而，在GNU GCC实现中，省略的成员被初始化为零或类似零的适合类型的值。如GNU GCC文档第6.27节中所述:

省略的字段成员隐式初始化，与具有静态存储持续时间的对象相同。

根据官方博客文章c++一致性路线图，微软Visual c++编译器应该从2013版开始支持指定的初始化器。MSDN Visual Studio文档中的初始化联盟和Initializers的文章建议将未命名成员初始化为类似于GNU GCC的类似于零的适当值。

ISO/IEC 9899:2011标准(通常称为C11)已经取代了ISO/IEC 9899:1999，在第6.7.9节初始化中保留了指定的初始化器。决议草案还保留第9段不变。

新的ISO/IEC 9899:2018标准(通常称为C18)已经取代了ISO/IEC 9899:2011，在第6.7.9节初始化中保留了指定的初始化器。决议草案还保留第9段不变。

C中的结构可以像这样声明和初始化:

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

我已经阅读了Microsoft Visual Studio 2015初始化聚合类型文档，所有形式的初始化{…}被解释在那里，但初始化点，命名为“designator”没有被提到。这也行不通。

C99标准第6.7.8章初始化解释了指示符的可能性，但在我看来，对于复杂结构来说，这并不是很清楚。C99标准格式为pdf。

在我看来，这样也许更好

对所有静态数据使用= {0};-initialization。编写机器代码比较省力。 例如，使用宏进行初始化 typedef MyStruct_t{int x, int a, int b;} MyStruct; 定义INIT_MyStruct(A,B) {0, A,B}

宏可以被调整，它的参数列表可以独立于改变的结构内容。如果初始化的元素较少，则是合适的。它也适用于嵌套结构。 3.在子例程中初始化:

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

这个例程看起来像C语言中的面向对象的。使用这个，而不是这个来用c++编译它!

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

我一直在寻找一个很好的方法来初始化我的结构，我已经使用下面的(C99)。这让我可以以与普通类型相同的方式初始化单个结构或结构数组。

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

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

这可以在代码中使用:

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

这可以通过不同的方式来实现:

MY_TYPE a = { true, 1, 0.1 };

MY_TYPE a = { .stuff = 0.1, .flag = true, .value = 1 }; //designated initializer, not available in c++

MY_TYPE a;
a = (MY_TYPE) { true,  1, 0.1 };

MY_TYPE m (true, 1, 0.1); //works in C++, not available in C

此外，可以在声明结构时定义成员。

#include <stdio.h>

struct MY_TYPE
{
    int a;
    int b;
}m = {5,6};

int main()
{
    printf("%d  %d\n",m.a,m.b);    
    return 0;
}

添加到所有这些好的回答总结如何在C中初始化一个结构(联合和数组)，特别是设计的初始化器。

标准的初始化

struct point 
{
    double x;
    double y;
    double z;
}

p = {1.2, 1.3}; 

---

指定初始化

指定初始化式出现于ISO C99，是在C语言中初始化struct、union或数组时的一种不同的、更动态的初始化方式。

与标准初始化的最大区别是，您不必按固定顺序声明元素，也可以省略元素。

摘自GNU指南:

标准C90要求初始化式的元素以固定的顺序出现，与初始化数组或结构中元素的顺序相同。

在ISO C99中，您可以以随机顺序给出元素，指定它们应用的数组下标或结构字段名，GNU C也允许在C90模式中作为扩展

---

例子

1. 数组索引

标准的初始化

int a[6] = { 0, 0, 15, 0, 29, 0 };

指定的初始化

int a[6] = {[4] = 29, [2] = 15 }; // or
int a[6] = {[4]29 , [2]15 }; // or
int widths[] = { [0 ... 9] = 1, [10 ... 99] = 2, [100] = 3 };

2. 结构或联合:

标准的初始化

struct point { int x, y; };

指定的初始化

struct point p = { .y = 2, .x = 3 }; or
struct point p = { y: 2, x: 3 };

3.将命名元素与连续元素的普通C初始化结合起来:

标准的初始化

int a[6] = { 0, v1, v2, 0, v4, 0 };

指定的初始化

int a[6] = { [1] = v1, v2, [4] = v4 };

4. 其他:

标记数组初始化式的元素

int whitespace[256] = { [' '] = 1, ['\t'] = 1, ['\h'] = 1,
                        ['\f'] = 1, ['\n'] = 1, ['\r'] = 1 };

写一系列的“。”' = '前面的Fieldname '和' [index] '指示符指定要初始化的嵌套子对象

struct point ptarray[10] = { [2].y = yv2, [2].x = xv2, [0].x = xv0 };

---

指南

Designated-initializers-c | geeksforgeeks.org using-designated-initializers Tutorialspoint.com |designing-initializs-inc