1、前言
今天在公司看一同事寫的代碼，代碼中用到了struct，初始化一個struct用的是亂序格式，如下代碼所示:
typedef struct _data_t { int a; int b; }data_t; data_t data = { .a = 10, .b = 20, };
通常初始化一個結構體的方式是按序初始化，形如：data_t data={10,20}。感覺很好奇，如是上網百度一下，發現linux下struct初始化可以采用順序和亂序兩種方式，而亂序又有兩種不同的形式。本文總結一下struct兩種初始化方式的優缺點，並給出完整的測試程序。
2、順序初始化
教科書上講C語言結構體初始化是按照順序方式來講的，沒有涉及到亂序的方式。順序初始化struct必須要按照成員的順序進行，缺一不可，如果結構體比較大，很容易出現錯誤，而且表現形式不直觀，不能一眼看出各個struct各個數據成員的值。
3、亂序初始化
亂序初始化是C99標准新加的，比較直觀的一種初始化方式。相比順序初始化而言，亂序初始化就如其名，成員可以不按照順序初始化，而且可以只初始化部分成員，擴展性較好。linux內核中采用這種方式初始化struct。
亂序初始化有兩種方式，一種是用點（.）符號，一種是用冒號（：）。方式1是C99標准，方式2是GCC的擴展，強烈建議使用第一種方式。
4、測試程序
1 /********************************* 2 * linux下C語言結構體初始化方法 3 * @author Anker @date:2014/02/11 4 * *******************************/ 5 6 #include <stdio.h> 7 8 //函數指針 9 typedef int (*caculate_cb)(int a, int b); 10 //結構體定義 11 typedef struct _oper { 12 int a; 13 int b; 14 caculate_cb cal_func; 15 } oper; 16 //加法函數定義 17 int add(int a, int b) 18 { 19 return (a+b); 20 } 21 22 int main() 23 { 24 int ret = 0; 25 //順序初始化結構體1 26 oper oper_one = {10, 20, add}; 27 //亂序初始化結構體2 28 oper oper_two = { 29 .b = 30, 30 .a = 20, 31 .cal_func = &add, 32 }; 33 //亂序初始化結構體3 34 oper oper_three = { 35 cal_func:&add, 36 a:40, 37 b:20, 38 }; 39 ret = oper_one.cal_func(oper_one.a, oper_one.b); 40 printf("oper_one caculate: ret = %d\n", ret); 41 ret = oper_two.cal_func(oper_two.a, oper_two.b); 42 printf("oper_two caculate: ret = %d\n", ret); 43 ret = oper_three.cal_func(oper_three.a, oper_three.b); 44 printf("oper_three caculate: ret = %d\n", ret); 45 return 0; 46 }
測試結果如下圖所示：
5、參考資料
http://blog.csdn.net/adaptiver/article/details/7494081
C語言變長數組data[0]【總結】
1、前言
今天在看代碼中遇到一個結構中包含char data[0]，第一次見到時感覺很奇怪，數組的長度怎么可以為零呢？於是上網搜索一下這樣的用法的目的，發現在linux內核中，結構體中經常用到data[0]。這樣設計的目的是讓數組長度是可變的，根據需要進行分配。方便操作，節省空間。
2、data[0]結構
經常遇到的結構形狀如下：
struct buffer { int data_len; //長度 char data[0]; //起始地址 };
在這個結構中，data是一個數組名；但該數組沒有元素；該數組的真實地址緊隨結構體buffer之后，而這個地址就是結構體后面數據的地址（如果給這個結構體分配的內容大於這個結構體實際大小，后面多余的部分就是這個data的內容）；這種聲明方法可以巧妙的實現C語言里的數組擴展。
寫個程序對比char data[0]，char *data, char data[]，如下所示：
1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <string.h> 4 #include <stdint.h> 5 6 typedef struct 7 { 8 int data_len; 9 char data[0]; 10 }buff_st_1; 11 12 typedef struct 13 { 14 int data_len; 15 char *data; 16 }buff_st_2; 17 18 typedef struct 19 { 20 int data_len; 21 char data[]; 22 }buff_st_3; 23 24 int main() 25 { 26 printf("sizeof(buff_st_1)=%u\n", sizeof(buff_st_1)); 27 printf("sizeof(buff_st_2)=%u\n", sizeof(buff_st_2)); 28 printf("sizeof(buff_st_3)=%u\n", sizeof(buff_st_3)); 29 30 buff_st_1 buff1; 31 buff_st_2 buff2; 32 buff_st_3 buff3; 33 34 printf("buff1 address:%p,buff1.data_len address:%p,buff1.data address:%p\n", 35 &buff1, &(buff1.data_len), buff1.data); 36 37 printf("buff2 address:%p,buff2.data_len address:%p,buff2.data address:%p\n", 38 &buff2, &(buff2.data_len), buff2.data); 39 40 printf("buff3 address:%p,buff3.data_len address:%p,buff3.data address:%p\n", 41 &buff3, &(buff3.data_len), buff3.data); 42 43 return 0; 44 }
從結果可以看出data[0]和data[]不占用空間，且地址緊跟在結構后面，而char *data作為指針，占用4個字節，地址不在結構之后。
3、實際當中的用法
在實際程序中，數據的長度很多是未知的，這樣通過變長的數組可以方便的節省空間。對指針操作，方便數據類型的轉換。測試程序如下：
1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <string.h> 4 #include <stdint.h> 5 6 typedef struct 7 { 8 int data_len; 9 char data[0]; 10 }buff_st_1; 11 12 typedef struct 13 { 14 int data_len; 15 char *data; 16 }buff_st_2; 17 18 typedef struct 19 { 20 int data_len; 21 char data[]; 22 }buff_st_3; 23 24 typedef struct 25 { 26 uint32_t id; 27 uint32_t age; 28 }student_st; 29 30 31 void print_stu(const student_st *stu) 32 { 33 printf("id:%u,age:%u\n", stu->id, stu->age); 34 } 35 36 int main() 37 { 38 student_st *stu = (student_st *)malloc(sizeof(student_st)); 39 stu->id = 100; 40 stu->age = 23; 41 42 student_st *tmp = NULL; 43 44 buff_st_1 *buff1 = (buff_st_1 *)malloc(sizeof(buff_st_1) + sizeof(student_st)); 45 buff1->data_len = sizeof(student_st); 46 memcpy(buff1->data, stu, buff1->data_len); 47 printf("buff1 address:%p,buff1->data_len address:%p,buff1->data address:%p\n", 48 buff1, &(buff1->data_len), buff1->data); 49 50 tmp = (student_st*)buff1->data; 51 print_stu(tmp); 52 53 buff_st_2 *buff2 = (buff_st_2 *)malloc(sizeof(buff_st_2)); 54 buff2->data_len = sizeof(student_st); 55 buff2->data = (char *)malloc(buff2->data_len); 56 memcpy(buff2->data, stu, buff2->data_len); 57 printf("buff2 address:%p,buff2->data_len address:%p,buff2->data address:%p\n", 58 buff2, &(buff2->data_len), buff2->data); 59 60 tmp = (student_st *)buff2->data; 61 print_stu(tmp); 62 63 buff_st_3 *buff3 = (buff_st_3 *)malloc(sizeof(buff_st_3) + sizeof(student_st)); 64 buff3->data_len = sizeof(student_st); 65 memcpy(buff3->data, stu, buff3->data_len); 66 printf("buff3 address:%p,buff3->data_len address:%p,buff3->data address:%p\n", 67 buff3, &(buff3->data_len), buff3->data); 68 69 tmp = (student_st*)buff1->data; 70 print_stu(tmp); 71 72 free(buff1); 73 74 free(buff2->data); 75 free(buff2); 76 77 free(buff3); 78 free(stu); 79 return 0; 80 }
程序執行結果如下：
采用char *data，需要進行二次分配，操作比較麻煩，很容易造成內存泄漏。而直接采用變長的數組，只需要分配一次，然后進行取值即可以。
參考資料：
http://blog.csdn.net/maopig/article/details/7243646
char data[0]用法總結
struct MyData
{
int nLen;
char data[0];
}; 開始沒有理解紅色部分的內容，上網搜索下，發現用處很大，記錄下來。
在結構中，data是一個數組名；但該數組沒有元素；該數組的真實地址緊隨結構體MyData之后，而這個地址就是結構體后面數據的地址（如果給這個結構體分配的內容大於這個結構體實際大小，后面多余的部分就是這個data的內容）；這種聲明方法可以巧妙的實現C語言里的數組擴展。
實際用時采取這樣：
struct MyData *p = (struct MyData *)malloc(sizeof(struct MyData )+strlen(str))
這樣就可以通過p->data 來操作這個str。
示例：
#include <iostream>
using namespace std;
struct MyData
{
int nLen;
char data[0];
};
int main()
{
int nLen = 10;
char str[10] = "123456789";
cout << "Size of MyData: " << sizeof(MyData) << endl;
MyData *myData = (MyData*)malloc(sizeof(MyData) + 10);
memcpy(myData->data, str, 10);
cout << "myData's Data is: " << myData->data << endl;
free(myData);
return 0;
}
輸出：
Size of MyData: 4
myData's Data is: 123456789
由於數組沒有元素，該數組在該結構體中分配占用空間，所以sizeof(struct Mydata) = 4。
malloc申請的是14個字節的連續空間，它返回一個指針指向這14個字節，強制轉換成struct INFO的時候，前面4個字節被認為是Mydata結構，后面的部分拷貝了“123456789”的內容。
在讀程序中經常會看到這樣的定義char data[0]，這是一個什么樣的用法，有什么好處，在哪些地方用到？
本文的主要目的就是闡明這個定義的作用，以及適用范圍，這需要對指針的概念和操作系統的內存模型有一個情形的認識。
首先看一段程序：
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef struct _Info
{
int i;
char data[0];
}Info;
int main(int argc, char* argv[])
{
printf("%d/n",sizeof(Info));
return 0;
}
程序的執行結果是：4。整數i就占了4個字節，這表明data沒有占用空間。data是一個數組名；該數組沒有元素；該數組的真實地址緊隨結構體Info之后；這種聲明方法可以巧妙的實現C語言里的數組擴展。
記住上面的結構體不同於：
typedef struct _Info
{
int i;
char* data;
}Info;
這個結構體占用8個字節的空間，因為指針類型要占用4個字節的空間。
再看一個例子：
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef struct _Info
{
int i;
char data[0];
}Info;
int main(int argc, char* argv[])
{
char buf[10] = "123456789";
void* p = NULL;
printf("%d/n",sizeof(Info));
Info* info = (Info*)malloc(sizeof(Info) + 10);
p = (void*)info->data;
printf("addr of info is %p. addr of data is %p ./n", info, p);
strcpy((char*)p, buf);
printf("%s/n", (char*)p);
return 0;
}
程序的執行結果見下圖：
可知，data的地址是緊隨結構體之后的。