點選上方「Linux開源社群」，選擇「設為星標」
優質文章，及時送達
☞【幹貨】
轉自：網路
結構體的定義
結構體(struct)是由一系列具有相同型別或不同型別的數據構成的數據集合，也叫結構。
結構體和其他型別基礎數據型別一樣，例如 int 型別，char型別；只不過結構體可以做成你想要的數據型別，以方便日後的使用。
在實際計畫中，結構體是大量存在的。研發人員常使用結構體來封裝一些內容來組成新的型別。由於C語言無法操作資料庫，所以在計畫中透過對結構體內部變量的操作將大量的數據儲存在記憶體中，以完成對數據的儲存和操作。
在實際問題中有時候我們需要幾種數據型別一起來修飾某個變量。
例如一個學生的資訊就需要學號（字串），姓名（字串），年齡（整型）等等。
這些數據型別都不同但是他們又是表示一個整體，要存在聯系，那麽我們就需要一個新的數據型別 ——結構體，它就將不同型別的數據存放在一起，作為一個整體進行處理。
結構體在函式中的作用不是簡便，其最主要的作用就是封裝。封裝的好處就是可以再次利用。讓使用者不必關心這個是什麽，只要根據定義使用就可以了。
結構體的大小不是結構體元素單純相加就行的，因為我們現在主流的電腦使用的都是 32Bit 字長的 CPU，對這型別的 CPU 取 4 個字節的數要比取一個字節要高效，也更方便。所以在結構體中每個成員的首地址都是4的整數倍的話，取數據元素時就會相對更高效，這就是記憶體對齊的由來。
每個特定平台上的編譯器都有自己的預設「對齊系數」(也叫對齊模數)。程式設計師可以透過預編譯命令 #pragma pack(n)，n=1,2,4,8,16 來改變這一系數，其中的 n 就是你要指定的「對齊系數」。
規則
1、成員變數對齊規則：結構(struct)(或聯合(union))的成員變數，第一個成員變數放在 offset 為 0 的地方，以後每個成員變數的對齊按照 #pragma pack 指定的數值和這個成員變數自身長度中，比較小的那個進行。
2、結構(或聯合)的整體對齊規則：在成員變數完成各自對齊之後，結構(或聯合)本身也要進行對齊，對齊將按照#pragma pack指定的數值和結構(或聯合)最大成員變數長度中，比較小的那個進行。
3、結合1、2可推斷：當#pragma pack的n值等於或超過所有成員變數長度的時候，這個n值的大小將不產生任何效果。
在C語言中，可以定義結構體型別，將多個相關的變量包裝成為一個整體使用。在結構體中的變量，可以是相同、部份相同，或完全不同的數據型別。 結構體不能包含函式。
在物件導向的程式設計中，物件具有狀態（內容）和行為，狀態保存在成員變量中，行為透過成員方法（函式）來實作。C語言中的結構體只能描述一個物件的狀態，不能描述一個物件的行為。在C++中，考慮到 C 語言到 C++ 語言過渡的連續性，對結構體進行了擴充套件，C++的結構體可以包含函式，這樣，C++的結構體也具有類的功能，與 class 不同的是，結構體包含的函式預設為 public，而不是 private。
結構體聲明
//聲明一個結構體 struct book { char title[MAXTITL];//一個字串表示的titile 題目 ； char author[MAXAUTL];//一個字串表示的author作者 ； float value;//一個浮點型表示的value價格；}; //註意分號不能少，這也相當於一條語句；
這個聲明描述了一個由兩個字元陣列和一個float變量組成的結構體。
但是註意，它並沒有建立一個實際的數據物件，而是描述了一個組成這類物件的元素。
因此，我們有時候也將結構體聲明叫做樣版，因為它勾勒出數據該如何儲存，並沒有例項化數據物件。
下面介紹一下上面的結構體聲明；
1、首先使用關鍵字struct，它表示接下來是一個結構體。
2、後面是一個可選的標誌（book），它是用來參照該結構體的快速標記。
因此我們以後就可以這樣建立數據物件
struct book library；//把library設為一個可以使用book結構體的結構體變量，則library這個變量就包含了其book結構體中的所有元素
3、接下來就是一個花括弧，括起了結構體成員列表，及每個成員變量，使用的都是其自己的聲明方式來描述，用分號來結束描述；
例如：char title[MAXTITL]; 字元陣列就是這樣聲明的，用分號結束；
註意 ：其中每個成員可以使用任何一種C數據結構甚至是其他的結構體，也是可以的；
4、在結束花括弧後的分號表示結構體設計定義的結束。
關於其struct聲明的位置，也就是這段程式碼要放到哪裏。 同樣這也是具有作用域的。
這種聲明如果放在任何函式的外面，那麽則標記可以在在本檔中，該聲明後面的所有函式都可以使用。
如果這種聲明在某個函式的內部，則它的標記只能在內部使用，並且在其聲明之後；
關於我們不斷說的，標記名是可選的，那麽我們什麽時候可以省略，什麽時候一定不能省略呢？
如果是上面那種聲明定義的方法，並且想在一個地方定義結構體設計，而在其他地方定義實際的結構體變量，那麽就必須使用標記；
可以省略，設計的同時就建立該結構體變量，但是這種設計是免洗的。
一般格式就是：
struct 結構體名(也就是可選標記名）{ 成員變量；}；//使用分號表示定義結束。
C 語言結構體定義的三種方式
1、最標準的方式:
#include <stdio.h>struct student //結構體型別的說明與定義分開。聲明{ int age; /*年齡*/ float score; /*分數*/ char sex; /*性別*/};int main (){ struct student a={ 20,79,'f'}; //定義 printf("年齡：%d 分數：%.2f 性別：%c\n", a.age, a.score, a.sex ); return 0;}
2、不環保的方式
#include <stdio.h>struct student /*聲明時直接定義*/{ int age; /*年齡*/ float score; /*分數*/ char sex; /*性別*/ /*這種方式不環保，只能用一次*/} a={21,80,'n'};int main (){ printf("年齡：%d 分數：%.2f 性別：%c\n", a.age, a.score, a.sex );}
3、最奈何人的方式
#include <stdio.h>struct //直接定義結構體變量，沒有結構體型別名。這種方式最爛{ int age; float score; char sex;} t={21,79,'f'};int main (){ printf("年齡：%d 分數：%f 性別：%c\n", t.age, t.score, t.sex); return 0;}
定義結構體變量
之前我們結構體型別的定義（結構體的聲明）只是告訴編譯器該如何表示數據，但是它沒有讓電腦為其分配空間。
我們要使用結構體，那麽就需要建立變量，也就是結構體變量；
建立一個結構體變量；
struct book library；
看到這條指令，編譯器才會建立一個結構體變量library，此時編譯器才會按照book樣版為該變量分配記憶體空間，並且這裏儲存空間都是以這個變量結合在一起的。
這也是後面存取結構體變量成員的時候，我們就要用到結構體變量名來存取。
分析：
struct book的作用：
在結構體聲明中，struct book所起到的作用就像 int 等基礎數據型別名作用一樣。
struct book s1，s2，*ss；
定義兩個 struct book 結構體型別的結構體變量，還定義了一個指向該結構體的指標，其 ss 指標可以指向 s1，s2，或者任何其他的book結構體變量。
struct book library；
等效於：
struct book{char … …. ….. }library；
這兩種是等效的，只是第一種可以減少程式碼的編寫量；
現在還是回到剛才提及的那個問題，可選標誌符什麽時候可以省略；
其一：
struct{ char title[MAXTITL]; char author[MAXAUTL]; float value；}library;
註意，這裏不再是定義聲明結構體型別，而是直接建立結構體變量了，這個編譯器會分配記憶體的；
這樣的確可以省略識別元也就是結構體名，但是只能使用一次；因為這時，聲明結構體的過程和定義結構體變量的過程和在了一起，並且各成員變量沒有初始化。
如果你想多次使用一個結構體模組，這樣子是行不通的。
其二，
用 typedef 定義新型別名來代替已有型別名，即給已有型別重新命名；
一般格式為；typedef 已有型別 新型別名；
typedef int Elem; typedef struct{int date; ..... .....}STUDENT;STUDENT stu1,stu2;
總結一下關於結構體變量的定義：
1、先定義結構體型別後再定義結構體變量；
格式為：struct 結構體名 變量名列表；
//註意這種之前要先定義結構體型別後再定義變量；struct book s1，s2，*ss；
2、 在定義結構體型別的同時定義結構體變量；
格式為：
struct 結構體名{ 成員列表；}變量名列表；//這裏結構體名是可以省的，但盡量別省；struct book{ char title[MAXTITL];//一個字串表示的titile 題目 ； char author[MAXAUTL];//一個字串表示的author作者 ； float value;//一個浮點型表示的value價格；}s1，s2
直接定義結構體型別變量，就是第二種中省略結構體名的情況；
這種方式不能指明結構體型別名而是直接定義結構體變量，並且在只定義一次結構體變量時適用，無結構體名的結構體型別是無法重復使用的。
也就是說，後面程式不能再定義此型別變量了，除非再寫一次重復的 struct。
對於結構體變量的初始化
先回憶一下關於基本數據型別和陣列型別的初始化：
int a = 0；int array[4] = {1,2,3,4};//每個元素用逗號隔開
回憶一下陣列初始化問題：
再回到結構體變量的初始化吧
關於結構體變量的初始化與初始化陣列類似；
也是使用花括弧括起來，用逗號分隔的初始化好計畫列表。註意， 每個初始化計畫必須要和要初始化的結構體成員型別相匹配。
struct book s1={ //對結構體初始化 "yuwen", //title為字串 "guojiajiaoyun", //author為字元陣列 22.5 //value為flaot型 };//要對應起來，用逗號分隔開來，與陣列初始化一樣；
加入一點小知識，關於結構體初始化和儲存類時期的問題：如果要初始化一個具有靜態儲存時期的結構體，初始化計畫列表中的值必須是常量運算式；
註意，如果在定義結構體變量的時候沒有初始化，那麽後面就不能全部一起初始化了；意思就是：
/////////這樣是可以的，在定義變量的時候就初始化了；struct book s1={ //對結構體初始化 "guojiajiaoyun",//author為字元陣列 "yuwen",//title為字串 22.5};/////////這種就不行了，在定義變量之後，若再要對變量的成員賦值，那麽只能單個賦值了；struct book s1;s1={ "guojiajiaoyun",//author為字元陣列 "yuwen",//title為字串 22.5};//這樣就是不行的，只能在定義的時候初始化才能全部賦值，之後就不能再全體賦值了，只能單個賦值；只能：s1.title = "yuwen";........//單個賦值；
對於結構體的指定初始化：
存取結構體成員
結構體就像一個超級陣列，在這個超級陣列內，一個元素可以是char型別，下個元素就可以是flaot型別，再下個還可以是int陣列型，這些都是存在的。
在陣列裏面我們透過下標可以存取一個陣列的各個元素，那麽如何存取結構體中的各個成員呢？
用結構成員運算子點（.）就可以了；
結構體變量名.成員名;
註意，點其結合性是自左至右的，它在所有的運算子中優先級是最高的；
例如，s1.title指的就是s1的title部份；s1.author指的就是s1的author部份；s1.value指的就是s1的value部份。
然後就可以像字元陣列那樣使用s1.title，像使用float數據型別一樣使用s1.value；
註意，s1 雖然是個結構體，但是 s1.value 卻是 float 型的。
因此 s1.value 就相當於 float 型別的變量名一樣，按照 float 型別來使用；
例如：
printf(「%s\n%s\n%f」,s1.title,s1.author,s1.value); //存取結構體變量元素
註意 scanf(「%d」,&s1.value); 這語句存在兩個運算子，&和結構成員運算子點。
按照道理我們應該將（s1.value括起來，因為他們是整體，表示s1的value部份）但是我們不括起來也是一樣的，因為點的優先級要高於&。
如果其成員本身又是一種結構體型別，那麽可以透過若幹個成員運算子，一級一級的找到最低一級成員再對其進行操作；
結構體變量名.成員.子成員………最低一級子成員;
struct date{ int year; int month; int day;};struct student{ char name[10]; struct date birthday;}student1;//若想參照student的出生年月日，可表示為；student.brithday.year；brithday是student的成員；year是brithday的成員；
整體與分開
可以將一個結構體變量作為一個整體賦值給另一相同型別的結構體變量，可以到達整體賦值的效果；這個成員變量的值都將全部整體賦值給另外一個變量；微信搜尋公眾號：架構師指南，回復：架構師 領取資料 。
不能將一個結構體變量作為一個整體進行輸入和輸出；在輸入輸出結構體數據時，必須分別指明結構體變量的各成員；
小結 ：除去「相同型別的結構體變量可以相互整體賦值」外，其他情況下，不能整體參照，只能對各個成員分別參照；
結構體長度
數據型別的字節數：
16位元編譯器
char ：
1個字節
char*(即指標變量):
2個字節
short int :
2個字節
int：
2個字節
unsigned int :
2個字節
float:
4個字節
double:
8個字節
long:
4個字節
long long:
8個字節
unsigned long:
4個字節
32位元編譯器
char ：
1個字節
char*（即指標變量）:
4個字節（32位元的尋址空間是2^32, 即32個bit，也就是4個字節。
同理64位元編譯器）
short int : 2個字節
int：
4個字節
unsigned int :
4個字節
float:
4個字節
double:
8個字節
long:
4個字節
long long:
8個字節
unsigned long:
4個字節
那麽，下面這個結構體型別占幾個字節呢？
typedef struct{ char addr; char name; int id;}PERSON;
透過printf("PERSON長度=%d字節\n",sizeof(PERSON));可以看到結果：
結構體字節對齊
透過下面的方式，可以清楚知道為什麽是8字節。
1、定義20個char元素的陣列
char ss[20]={0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29};
2、定義結構體型別的指標ps指向ss陣列
PERSON *ps=(PERSON *)ss;
3、打印輸出各個成員
printf("0xx,0xx,0xx\n",ps->addr,ps->name,ps->id);printf("PERSON長度=%d字節\n",sizeof(PERSON));
可以看到addr和name都只占一個字節，但是未滿4字節，跳過2字節後才是id的值，這就是4字節對齊。結構體成員有int型，會自動按照4字節對齊。
把結構體成員順序調換位置
typedef struct{ char addr; int id; char name;}PERSON;
輸出:
按照下面的順序排列：
typedef struct{int id;char addr;char name;}PERSON;
輸出：
可見，結構體成員順序最佳化，可節省空間。
如果全部成員都是 char 型，會按照 1 字節對齊，即
typedef struct{char addr;char name; char id;}PERSON;
輸出結果：
結構體巢狀
結構體巢狀結構體方式：
typedef struct{ char addr; char name; int id;}PERSON;typedef struct{ char age; PERSON ps1;}STUDENT;
先定義結構體型別PERSON，再定義結構體STUDENT，PERSON作為它的一個成員。
按照前面的方法，打印各成員的值。
1、定義STUDENT 指標變量指向陣列 ss
STUDENT *stu=(STUDENT *)ss;
2、打印輸出各成員和長度
printf("0xx,0xx,0xx,0xx\n",stu->ps1.addr,stu->ps1.name,stu->ps1.id,stu->age);printf("STUDENT長度=%d字節\n",sizeof(STUDENT));
調換STUDENT成員順序，
typedef struct{ PERSON ps1; char age;}STUDENT;
輸出結果：
結構體巢狀其實沒有太意外的東西，只要遵循一定規律即可：
//對於「一錘子買賣」，只對最終的結構體變量感興趣，其中A、B也可刪，不過最好帶著 struct A{ struct B{ int c; }b; }a; //使用如下方式存取：a.b.c = 10;
特別的,可以一邊定義結構體B，一邊就使用上：
struct A{ struct B{ int c; }b;struct B sb;}a;
使用方法與測試：
a.b.c = 11; printf("%d\n",a.b.c); a.sb.c = 22; printf("%d\n",a.sb.c);
結果無誤。
但是如果巢狀的結構體B是在A內部才聲明的，並且沒定義一個對應的物件實體b，這個結構體B的大小還是不算進結構體A中。
占用記憶體空間
struct結構體，在結構體定義的時候不能申請記憶體空間，不過如果是結構體變量，聲明的時候就可以分配——兩者關系就像C++的類與物件，物件才分配記憶體（不過嚴格講，作為程式碼段，結構體定義部份「.text」真的就不占空間了麽？當然，這是另外一個範疇的話題）。
結構體的大小通常（只是通常）是結構體所含變量大小的總和，下面打印輸出上述結構體的size：
printf("size of struct man:%d\n",sizeof(struct man)); printf("size:%d\n",sizeof(Huqinwei));
結果毫無懸念，都是28：分別是char陣列20，int變量4，浮點變量4。
下邊說說不通常的情況
對於結構體中比較小的成員，可能會被強行對齊，造成空間的空置，這和讀取記憶體的機制有關。
為了效率，通常32位元機按4字節對齊，小於的都當4字節，有連續小於4字節的，可以不著急對齊，等到湊夠了整，加上下一個元素超出一個對齊位置，才開始調整，比如3+2或者1+4，後者都需要另起（下邊的結構體大小是8bytes），相關例子就多了，不贅述。
struct s{ char a; short b; int c; };
相應的，64 位機按 8 字節對齊。不過對齊不是絕對的，用#pragma pack()可以修改對齊，如果改成1，結構體大小就是實實在在的成員變量大小的總和了。
和C++的類不一樣，結構體不可以給結構體內部變量初始化，。
如下，為錯誤示範：
#include<stdio.h> //直接帶變量名struct stuff{// char job[20] = "Programmer"; // char job[]; // int age = 27; // float height = 185; };
PS：結構體的聲明也要註意位置的，作用域不一樣。
C++的結構體變量的聲明定義和C有略微不同，說白了就是更「物件導向」風格化，要求更低。
為什麽有些函式的參數是結構體指標型
如果函式的參數比較多，很容易產生「重復C語言程式碼」，例如：
int get_video(char **name, long *address, int *size, time_t *time, int *alg){ ...}int handle_video(char *name, long address, int size, time_t time, int alg){ ...}int send_video(char *name, long address, int size, time_t time, int alg){ ...}
上述C語言程式碼定義了三個函式：get_video() 用於獲取一段視訊資訊，包括：視訊的名稱，地址，大小，時間，編碼演算法。
然後 handle_video() 函式根據視訊的這些參數處理視訊，之後 send_video() 負責將處理後的視訊發送出去。下面是一次呼叫：
char *name = NULL;long address;int size, alg;time_t time;get_video(&name, &address, &size, &time, &alg);handle_video(name, address, size, time, alg);send_video(name, address, size, time, alg);
從上面這段C語言程式碼來看，為了完成視訊的一次「獲取」——「處理」——「發送」操作，C語言程式不得不定義多個變量，並且這些變量需要重復寫至少三遍。
雖說C語言程式的程式碼風格因人而異，但是「重復的程式碼」永遠是應盡力避免的，不管怎麽說，每次使用這幾個函式，都需要定義很多臨時變量，總是非常麻煩的。所以，這種情況下，完全可以使用C語言的結構體語法：
struct video_info{ char *name; long address; int size; int alg; time_t time;};
定義好 video_info 結構體後，上述三個C語言函式的參數可以如下寫，請看：
int get_video(struct video_info *vinfo){ ...}int handle_video(struct video_info *vinfo){ ...}int send_video(struct video_info *vinfo){ ...}
修改後的C語言程式碼明顯精簡多了，在函式內部，視訊的各個資訊可以透過結構體指標 vinfo 存取，例如：
printf("video name: %s\n", vinfo->name);long addr = vinfo->address;int size = vinfo->size;
事實上，使用結構體 video_info 封裝視訊資訊的各個參數後，呼叫這幾個修改後的函式也是非常簡潔的：
struct video_info vinfo = {0};get_video(&vinfo);handle_video(&vinfo);send_video(&vinfo);
從上述C語言程式碼可以看出，使用修改後的函式只需定義一個臨時變量，整個程式碼變得非常精簡。
讀者應該註意到了，修改之前的 handle_video() 和 send_video() 函式原型如下：
int handle_video(char *name, long address, int size, time_t time, int alg);int send_video(char *name, long address, int size, time_t time, int alg);
根據這段C語言程式碼，我們知道 handle_video() 和 send_video() 函式只需要讀取參數資訊，並不再修改參數，那為什麽使用結構體 video_info 封裝數據，修改後的 handle_video() 和 send_video() 函式參數是 struct video_info *指標型呢?
int handle_video(struct video_info *vinfo);int send_video(struct video_info *vinfo);
既然 handle_video() 和 send_video() 函式只需要讀取參數資訊，那我們就無需再使用指標型了呀？的確如此，這兩個函式的參數直接使用 struct video_info 型也是可以的：
int handle_video(struct video_info vinfo){ ...}int send_video(struct video_info vinfo){ ...}
似乎這種寫法和使用 struct video_info *指標型 參數的區別，無非就是函式內部存取數據的方式改變了而已。但是，如果讀者能夠想到我們之前討論過的 C語言函式的「棧幀」概念，應該能夠發現，使用指標型參數的 handle_video() 和 send_video() 函式效率更好，開銷更小。
嵌入式開發中，C語言位結構體用途詳解
在嵌入式開發中，經常需要表示各種系統狀態，位結構體的出現大大方便了我們，尤其是在進行一些硬體層操作和資料通訊時。但是在使用位結構體的過程中，是否深入思考一下它的相關內容？是否真正用到它的便利性，來提高系統效率？
下面將進行一些相關實驗（這裏以計畫開發中的實際程式碼為例）：
1. 位結構體型別設計
//data structure except for number structure typedef struct symbol_struct { uint_32 SYMBOL_TYPE :5; //data type,have the affect on "data display type" uint_32 reserved_1 :4; uint_32 SYMBOL_NUMBER :7; //effective data number in one element uint_32 SYMBOL_ACTIVE :1;//symbol active status uint_32 SYMBOL_INDEX :8; //data index in norflash,result is related to "xxx_BASE_ADDR" uint_32 reserved_2 :8; }SYMBOL_STRUCT, _PTR_ SYMBOL_STRUCT_PTR;
分析：這裏定義了一個位結構體型別 SYMBOL_STRUCT，那麽用該型別定義的變量都哪些內容呢？
看下面執行結果：
WORDS是定義的另一個外層型別定義封裝，可以把它當作變量來看待。WORDS變量裏前5個數據域的地址都是0x1ffff082c，而reserved_2的地址0x1fff0830,緊接著的PressureState變量是0x1fff0834。
開始以為：reserved_1 和 SYMBOL_TYPE 不在一個地址上，因為他們 5+4 共9位，超過了1個字節地址，但實際他們共用首地址了；而且reserved_2只定義了8位元，竟然實際占用了4個字節（0x1fff0834 - 0x1fff0830），我本來是想讓他占用1個字節的。
WORDS整體占了8個字節（0x1fff0834 - 0x1fff082c），設計分時析占用5個字節：
SYMBOL_TYPE 1個；reserved_1 1個；
SYMBOL_NUMBER+SYMBOL_ACTIVE 1個；
SYMBOL_INDEX 1個；reserved_2 1個；
uint_32 reserved_2 : 8; 占用4個字節，估計是uint_32在起作用，而這裏寫的8位元，只是我使用的有效位數，另外24位元空閑，如果在下面再定義一個uint_32 reserved_3 : 8，地址也是一樣的，都是以uint_32為單位取地址。
同理，上面的5個變量，共用一個地址就不足為奇了。而且有效位的分配不是連續進行的，例如 SYMBOL_TYPE+reserved_1 共9位，超過了一個字節，索性系統就分配兩個字節給他們，每人一個；SYMBOL_NUMBER+SYMBOL_ACTIVE 共8位元，一個字節就能搞定。
2、修改數據結構，驗證上述猜想
//data structure except for number structure typedef struct symbol_struct { uint_8 SYMBOL_TYPE :5; //data type,have the affect on "data display type" uint_8 reserved_1 :4; uint_8 SYMBOL_NUMBER :7; //effective data number in one element uint_8 SYMBOL_ACTIVE :1; //symbol active status uint_8 SYMBOL_INDEX :8; //data index in norflash,result is related to "xxx_BASE_ADDR" uint_8 reserved_2 :8; }SYMBOL_STRUCT,_PTR_ SYMBOL_STRUCT_PTR;
地址數據如下：
當換成uint_8後，可以看到地址空間占用大大減小，reserved_2 只占用1個字節(0x1fff069f - 0x1fff069e)，其他變量也都符合上面的結論猜想。但是，註意看上面黃色和紅色的語句，總感覺有些勉強，那麽我又會想，前兩個變量數據域是 9 位，那麽他們實際上是不是真正的獨立呢？雖然在 uint_8 上面他們是不同的地址，在uint_32 的時候是不是也是不同的地址空間呢？
3、分析結構體內部的數據域是否連續，看下圖及結果
本來假設： 由前 2 次試驗的結論，一共占用 8 個字節，節空間占用：(2+4)+(4+4)+(2+2+4)+(2+2)+(6)。可是，實際效果並不是想的那樣。實際只占用了 4 個字節，系統並沒有按照預想的方式，為 RESERVED 變量分配 4 個字節。
分析：
這些數據域，整體相加一共32位元，占用4個字節(不考慮數據對齊問題)。而實際確實是占用了4個字節，唯一的原因就是：這些數據域以緊湊的方式連結，沒有任何空閑位。實際是不是這樣呢？
看下圖和結果：
這裏為了驗證是否緊湊連結，用到了一個union數據，後面會講到用union不會對數據組織方式有任何影響，看實際與上次的一樣，也能分析出來。
主要是分析第2和第3個數據域是否緊密連結的。OBJECT_ACTIVE_PRE賦值0b00001111，NUMBER_ACTIVE賦值0b00000101，其他變量都是0，看到WORD數值0b1011111000000。分析WORD數據，可以看到這款MCU還是小端格式(高位數據在高端，低位數據在低端，這裏不對大小端進行討論)，斷開數據變成(0)10111 11000000，正好是0101+1111，OBJECT_ACTIVE_PRE數據域，跨越了兩個字節，並不是剛開始設想的那樣。這就印證了上面的緊密連結的結論，也符合數據結果輸出。
4、再次實驗，分析數據是否緊密連結，看下圖和結果
可以看到，RESERVED數據域已經不再屬於4個地址空間內了(0x1fff0518 - 0x1fff051b)，但是他們整體加起來還是32個位域。這說明數據中間肯定有「空隙」存在了，空隙在哪？看一下NUMBER_STATE，如果緊密的話它應該跟NUMBER_ACTIVE在同一個字節地址上，可是他們並不在一塊，「空隙」就存在這裏。
這兩個結構體有什麽不一樣？數據型別不一致，一個是uint_32，一個是uint_8。
綜上所述 ：數據型別影響的是編譯器在分配物理空間時的大小單位，uint_32 是以 4個字節為單位，而後面的位域則是指在已經分配好的物理空間內部再緊湊的方式分配數據位，當物理空間不能滿足位域時，那麽系統就再次以一定大小單位進行物理空間分配，這個單位就是上面提到的 uint_8 或者 uint_32。
舉例：上面 uint_32 時，這些位域不管是不是在一個字節地址上，如果能夠緊湊的分配在一個4字節空間大小上，就直接緊湊分配。如果不能則繼續分配(總空間超過4字節)，則再次以4字節空間分配，並把新的位域建立在新的地址空間上(條目1上的就是)。當 uint_8 時，很明顯如果位域不能緊湊的放在一個字節空間上，那麽就從新分配新的1字節空間大小，道理是一樣的。
5、結構體組合、共用體組合是否影響上述結論
可以看到，系統並沒有因為位結構體上面有uint_4的4字節變量或者共用體型別，就改變分配策略把位域都擠到4字節之內，看來他們是沒有什麽實質性聯系的。這裏把uint_32改成uint_8，或者把位結構體也替換掉，經我試驗證明，都是沒有任何影響的。
總結：
1、在操作位結構體時，要關註變量的位域是否在一個變量型別（uint_32或者uint_8）上，判斷占用空間大小。
2、除了位域，還要關註變量定義型別，因為編譯器空間分配始終是按型別分配的，位域只是指出了有效位(小於型別占用空間)，而且如果位域大於型別空間，編譯器直接報錯（如 uint_8 test :15，可自行實驗）。
3、這兩個因素都影響變量占用空間大小，具體可以結合偵錯視窗，透過地址分配分析判斷。
4、 最重要的一點 ：上面的所有結果，都是基於我自己的 CodeWarrior10.2 和MQX3.8 分析出來的，不同的編譯環境和作業系統，都可能會有不同的結果；而且即便是環境相同，編譯器的配置和最佳化選項都有可能影響系統處理結果。結論並不重要，主要想告訴大家這一塊隱藏陷阱，在以後處理類似問題時，要註意分析避讓並掌握方法。
-End-
讀到這裏說明你喜歡本公眾號的文章，歡迎 置頂（標星）本公眾號 Linux技術迷，這樣就可以第一時間獲取推播了~
在本公眾號，後台回復：Linux，領取2T學習資料 ！
推薦閱讀
1.
2.
3.
4.
