引子

在看Linux netlink部分的时候看到了这样的写法

1
2
3
4
5
6
struct netlink_kernel_cfg cfg = {
	.groups = RTNLGRP_MAX,
	.input = rtnetlink_rcv,
	.cb_mutext = &rtnl_mutex,
	.flags = NL_CFG_NONROOT_RECV
};

同时我由找到相关结构体定义

1
2
3
4
5
6
7
8
9
struct netlink_kernel_cfg {
	unsigned int groups;
	unsigned int flags;
	void (*input)(struct sk_buff *skb);
	struct mutex *cb_mutext;
	int (*bind)(struct net *net, int group);
	void (*unbind)(struct net *net,int group);
	bool (*compare)(struct net *net, struct sock, *sk);
}

通常情况下初始化一个结构体是按序初始化，比如struct netlink_kernel_cfg cfg = { RTNLGRP_MAX,...},对于这种初始化方式，很是好奇，于是查了下，发现linux下struct结构体初始化总的来说可以分为顺序方式 和 乱序 两种方式进行初始化，而乱序方式进行初始又分为两种形式，分别为’.’和’:’的两种方式。

概念

  1. 顺序初始化
    教科书上讲C语言结构体初始化是按照顺序方式来讲的，没有涉及到乱序的方式。顺序初始化struct必须要按照成员的顺序进行，缺一不可，如果结构体比较大，很容易出现错误，而且表现形式不直观，不能一眼看出各个struct各个数据成员的值。比如这样

    1
    2
    3
    4
    5
    typedef struct _data{
    	int a;
    	int b;
    }data;
    data d = {10,20};

  2. 乱序初始化
    乱序初始化是C99标准新加的，比较直观的一种初始化方式。相比顺序初始化而言，乱序初始化就如其名，成员可以不按照顺序初始化，而且可以只初始化部分成员，扩展性较好。linux内核中采用这种方式初始化struct。’.’方式是C99标准，’:’方式是GCC的扩展，建议使用第一种方式。

    • ‘.’方式初始化
      比如

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      typedef struct _data{
      	int a;
      	int b;
      }data;
      data d1 = {
      	.b = 10,
      	.a = 20
      };
      // 或者
      data d2 = {
      	.b = 10,
      };

    • ‘:’方式初始化
      比如

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      typedef struct _data{
      	int a;
      	int b;
      }data;
      data d1 = {
      	b : 10,
      	a : 20
      };
      // 或者
      data d2 = {
      	b : 10,
      };

举个栗子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
// 1.c
#include <stdio.h>

// 定义函数指针
typedef int (*calculate_func)(int a, int b);

// 定义结构体
typedef struct _oper {
    int a;
    int b;
    calculate_func cal;
} oper;

// 加法函数
int add (int a, int b)
{
    return (a + b);
}

int main()
{
    int ret = 0;
    // 顺序方式初始化
    oper oper_one = {10, 20, add};
    // 乱序方式初始化
    // .方式
    oper oper_two = {
        .b = 30,
        .a = 20,
        .cal = &add,
    };
    // :方式
    oper oper_three = {
        cal : &add,
        a : 40,
        b : 20,
    };


    ret = oper_one.cal(oper_one.a, oper_two.b);
    printf("oper_one calculate ret = %d\n", ret);


    ret = oper_two.cal(oper_two.a, oper_two.b);
    printf("oper_two calculate ret = %d\n", ret);

    ret = oper_three.cal(oper_three.a, oper_three.b);
    printf("oper_three calculate ret = %d\n", ret);
    return 0;
}

// 编译执行
// gcc 1.c
// ./a.out

执行结果为

1
2
3
oper_one calculate ret = 40
oper_two calculate ret = 50
oper_three calculate ret = 60

对于乱序方式，无论是’.’方式还是’:’方式，都是可以初始化部分成员的。