【C++】C和C++在结构体初始化时的差异

1、C初始化结构体

C语言初始化结构体由以下4种方法：

• 使用大括号：struct person laoer = {2, “laoer”, 18};
• 对每个成员单独赋值，其实这已经不属于初始化了，而是赋值：struct person laoda; laoda.id = 1;……
• 对成员使用"."初始化
• 对成员使用“:”初始化

参见下面的示例代码

#include <stdio.h>

struct person{
        int id;
        char *name;
        int age;
};

void print_person(const struct person *p)
{
        printf("id = %d,\tname = %s,\tage = %d\n", p->id, p->name, p->age);
}

int main()
{	
		# a）没有初始化，成员变量随机赋值
        struct person someone;
        someone.name = "someone";
        print_person(&someone);
	
		# b）没有初始化，对成员单独赋值
        struct person laoda;
        laoda.id = 1;
        laoda.name = "laoda";
        laoda.age = 19;
        print_person(&laoda);
		
		# c）使用大括号初始化，顺序要和定义时一致
        struct person laoer = {2, "laoer", 18};
        print_person(&laoer);
        
        # d）编译报错：使用大括号时，必须对前面的成员依次初始化
        //struct person laowu = {, "laowu", 15};
        //print_person(&laowu);
		
		# e）使用大括号时，可以忽略后面的成员，忽略的成员会随机初始化
        struct person laoliu = {6, "laoliu"};
        print_person(&laoliu);
        
        # f）成员使用“.”来初始化，可以不按照顺序来
        struct person laosan = {
                .age    = 17,
                .id     = 3,
                .name   = "laosan",
        };
        print_person(&laosan);
	
		# g）成员使用“:”来初始化，可以不按照顺序来
        struct person laosi = {
                name    :"laosi",
                age     :16,
                id      :4,
        };
        print_person(&laosi);
}

2、C++初始化结构体

使用g++编译C++的初始化结构体时，有了一些限制，没有gcc的宽松。

• 不能乱序初始化。本人测试结果：无论使用“.”还是“:”都必须和定义的顺序相同，可以忽略一些成员变量
  否则报错：designator order for field ‘’ does not match declaration order in ‘’
• 使用构造函数初始化和定义时初始化冲突，会报错：brace-enclosed initializer list
• 可以使用{}来代替C语言风格的={0}，来将成员初始化为默认值

参见下面的示例代码：

#include <iostream>

using namespace std;

struct person{
		# a）构造函数初始化 和 下面的定义时初始化冲突
        //person(){
                //id    = 99;
                //name  = "99";
                //age   = 99;
        //};

        int id;
        string name;
        int age;
};

void print_person(const struct person &p)
{
        cout << "id = " << p.id << "; name = " << p.name << "; age = " << p.age << endl;
}

int main()
{
		# b）未初始化，成员为随机值：id = 1440153600; name = ; age = 1440149144
        struct person someone;
        print_person(someone);
		
		# c）没有初始化，随后对成员单独赋值
        struct person laoda;
        print_person(laoda); // id = 1440149144; name = ; age = 1439324474
        laoda.id = 1;
        laoda.name = "laoda";
        laoda.age = 19;
        print_person(laoda);//id = 1; name = laoda; age = 19
	
		# d）使用大括号按照顺序初始化
        struct person laoer = {2, "laoer", 18};
        print_person(laoer);
	
		# e）使用“.”按照顺序初始化，否则报错
        struct person laosan = {
                .id     = 3,
                .name   = "laosan",
                .age    = 17,
        };
        print_person(laosan);
		
		# f）不能乱序初始化，否则报错：designator order for field ‘’ does not match declaration order in ‘’
        //struct person laosan1 = {
        //      .name   = "laosan1",
        //      .id     = 3,
        //      .age    = 17,
        //};
		
		# g）使用“:”按照顺序初始化，否则报错
        struct person laosi = {
                id      :4,
                name    :"laosi",
                age     :16,
        };
        print_person(laosi);

        # h）编译报错：使用大括号时，必须对前面的成员依次初始化
        //struct person laowu = {, "laowu", 15};
        //print_person(&laowu);
		
		# i）使用大括号时，可以忽略后面的成员，忽略的成员会随机初始化
        struct person laoliu = {6, "laoliu"};
        print_person(laoliu);
        
        # j）使用{}来代替C语言风格的={0}
        struct person laoqi = {};
        print_person(laoqi );//id = 0; name = ; age = 0
}

3、C++列表初始化

列表初始化 (C++11 起)：使用花括号初始化

3.1 直接列表初始化

T object { arg1, arg2, ... };					(1)	
T { arg1, arg2, ... }							(2)	
new T { arg1, arg2, ... }						(3)	
Class { T member { arg1, arg2, ... }; };		(4)	
Class::Class() : member{arg1, arg2, ...} {...	(5)	

(1) 花括号初始化
(2) 花括号初始化——无名临时变量量
(3) new 时初始化
(4) 不使用等号的、非静态数据成员初始化
(5) 在构造函数的成员初始化列表中，使用花括号初始化

3.2 复制列表初始化

T object = {arg1, arg2, ...};				(6)	
function( { arg1, arg2, ... } )				(7)	
return { arg1, arg2, ... } ;				(8)	
object[ { arg1, arg2, ... } ]				(9)	
object = { arg1, arg2, ... }				(10)	
Class { T member = { arg1, arg2, ... }; };	(11)

（6) 等号后的 花括号初始化
（7) 函数调用表达式中，先用 花括号初始化临时实参，再以临时实参对函数形参初始化
（8) 返回表达式的 return 语句中，先用 花括号初始化临时实参，再以临时实参对返回的对象初始化
（9) 在具有用户定义的 operator[] 的下标表达式中，以列表初始化对重载运算符的形参初始化
（10) 在赋值表达式中，以列表初始化对重载的运算符的形参初始化
（11) 在使用等号的非静态数据成员初始化