結構體

結構是一些值的集合，這些值稱為成員變數，結構的每個成員可以是不同型別的變數

結構體型別的宣告

比如描述一個學生的資訊

//結構體
struct Stu
{
	char name[20];//名字
	int age;//年齡
	char sex[5];//性別
	char id[20];//學號
}s1,s2;

struct Stu表示的是一個結構體型別，s1和s2表示的是一個結構體變數
藍色陰影部分表示的是一個結構體型別 (請搞清楚它們之間的關系)

而s1、s2、s3表示的都是結構體變數

結構體的特殊宣告

在宣告結構的時候，可以不完全的宣告

//匿名結構體型別
struct
{
 int a;
 char b;
 float c; 
}x;
 
struct
{
 int a;
 char b;
 float c; 
}a[20], *p;

int main()
{
	結構體指標變數指向結構體變數
	p = &x;
	return 0;
}

以上這種初始化指標變數的方式正確嗎？

很明顯這種初始化方式是不對的，因為匿名結構體型別他并沒有具體的型別，雖然指標變數和普通變數都是匿名結構體型別，可在編譯器卻不這么看待，編譯器把他們分為不同的型別看待，即使是成員一樣卻還是不同的型別，所以這種初始化方式是不對的，編譯器也很不客氣地報出警告，讀者可以把匿名結構體型別看作是一次性用品

結構體定義的錯誤示范

struct Node 
{
	int a;
	struct Node b;
};

編譯器也是很不客氣的不讓你通過

原因很簡單，這相當于是一次無限嵌套，struct Node結構體嵌套一個struct Node b，但是struct Node b又是一個結構體變數，它里面又是兩個成員就這樣會死回圈下去，那記憶體怎么為它開辟空間呢

結構的自參考

在結構中包含一個型別為該結構本身的成員是否可以呢
答案是可以的，將來博主寫資料結構文章的時候再來給大家展示這種代碼的寫法

//方法一
struct Node
{
	int data;
	struct Node *next;
};
//方法二
typedef struct Node
{
	int data;
	struct Node *next;
}Node;

結構體變數的定義和初始化

//初始化區域結構體變數
struct stu
{
	int age;
	char name[20];
	char sex[2];
	int score;
};
//結構體嵌套
struct secret
{
	struct stu se;
	int id;
	char skill;
};

//定義全域的結構體變數并初始化
struct stu lisi = {20,"李四"，"男"，99};

int main()
{
	//定義一個區域的結構體變數并初始化
	struct stu jack= {18,"jack","男"，100};
	//解套結構體變數的初始化
	struct stu tom= {{18,"jack","男"，100},200,"拳擊"};
	return 0;
}

結構體記憶體對齊

• 首先得掌握結構體的對齊規則：

  1. 第一個成員在與結構體變數偏移量為0的地址處，

  2. 其他成員變數要對齊到某個數字（對齊數）的整數倍的地址處，

  3. 對齊數 = 編譯器默認的一個對齊數 與 該成員大小的較小值，

5. VS中默認的值為8 Linux中的默認值為4

6. 結構體總大小為最大對齊數（每個成員變數都有一個對齊數）的整數倍，

7. 如果嵌套了結構體的情況，嵌套的結構體對齊到自己的最大對齊數的整數倍處，結構體的整體大小就是所 有最大對齊數（含嵌套結構體的對齊數）的整數倍，

如果讀到這里你都會的話，那么來看一組題目吧，計算的是結構體變數的大小

//練習1
struct S1
{
 char c1;
 int i;
 char c2;
};
printf("%d\n", sizeof(struct S1));// 12

分配出去的空間是從0 ~ 11這一段，紅×表示的是浪費掉的空間，從圖中我們可以看出c1是占用一個位元組的，而i是占用4個位元組的的，c2又占用一個位元組，成員所占用的空間再增加浪費的空間總的分配出去的空間就是12啦
如果再細致一點講解也可以根據前面的概念講解
c1呢會被分配在0位置處，因為他是結構體的第一個成員，它的型別是char，他會占用一個位元組的空間，而變數i的型別是int，int型別的大小是4位元組，vs的默認對齊數是8，結構體對齊數取較小值那就是4，所以會將變數i存放在4的位置處，從此開始存放四個位元組，而中間的1、2、3這三個位元組會白白浪費，而c2會被放在變數i的后面(char的大小是1，任何整數都是1的倍數)，那么0 ~ 8 就是9個位元組大小了，而結構體總大小為最大對齊數的整數倍，9明顯不滿足，所以會再浪費3個位元組，9 + 3 = 12，12剛好就是最大對齊數的整數倍數

緊接著再來看一組

//練習2
struct S2
{
 char c1;
 char c2;
 int i;
};

printf("%d\n", sizeof(struct S2));

c1所占用的空間是一個位元組，并且他是位于結構體的第一個變數，所以他被放在0位置處，c2是char型別占一個位元組，vs的默認對齊數是8，而char型別的大小是1，最大對齊數取1，所以被放在1的位置處，恰好是1的整數倍，由于i的變數型別是int，是占用4個位元組的空間，vs的默認對齊數是8，結構體對齊數取最小值，變數i的對齊數是4，所以他要被放在4的倍數位置處，那就是從位置為4開始存放4位元組空間的大小，而位置2和3處并沒有使用，所以會白白浪費點，系統為結構體變數分配出去的空間就是0 ~ 7的范圍，所以會分配8位元組空間

//練習3
struct S3
{
 double d;
 char c;
 int i;
};
printf("%d\n", sizeof(struct S3));

講到這里，相信你應該知道對齊規則了
以下留給大家推敲，進步空間留給自己，相信你很快就能掌握

再來看一組

//練習4-結構體嵌套問題
struct S3
{
 double d;
 char c;
 int i;
};
struct S4
{
 char c1;
 struct S3 s3;
 double d;
};
printf("%d\n", sizeof(struct S4));

如果嵌套了結構體的情況，嵌套的結構體對齊到自己的最大對齊數的整數倍處，結構體的整體大小就是所 有最大對齊數（含嵌套結構體的對齊數）的整數倍，c1依舊是放在0位置處只占用一個位元組，而結構體變數s3的對齊數就是8了，會從8的位置開始，填充16個位元組，成員d的對齊數是8會從24的位置開始往后填充8個位元組

為什么存在記憶體對齊?

大部分的參考資料都是如是說的：

1. 平臺原因(移植原因)： 不是所有的硬體平臺都能訪問任意地址上的任意資料的；某些硬體平臺只能在某些地址
   處取某些特定型別的資料，否則拋出硬體例外，
2. 性能原因： 資料結構(尤其是堆疊)應該盡可能地在自然邊界上對齊， 原因在于，為了訪問未對齊的記憶體，處理器
   需要作兩次記憶體訪問；而對齊的記憶體訪問僅需要一次訪問，
   總體來說：
   結構體的記憶體對齊是拿空間來換取時間的做法

那在設計結構體的時候，我們既要滿足對齊，又要節省空間，如何做到：

讓占用空間小的成員盡量集中在一起

修改默認對齊數

#pragma 這個預處理指令，可以改變我們的默認對齊數

#include <stdio.h>
#pragma pack(8)//設定默認對齊數為8
//12
struct S1
{
 char c1;
 int i;
 char c2; 
}

#pragma pack()//取消設定的默認對齊數，還原為默認

#pragma pack(1)//設定默認對齊數為1
//6
struct S2
{
 char c1;
 int i;
 char c2;
};

#pragma pack()//取消設定的默認對齊數，還原為默認

int main()
{
	printf("%d\n", sizeof(struct S1));// 12

	printf("%d\n", sizeof(struct S2));//6

	return 0;
}

結論： 結構在對齊方式不合適的時候，我么可以自己更改默認對齊數，

offsetof宏介紹

offsetof回傳指定成員從其父資料結構開始的位元組偏移量，

struct S1
{
	char c1;
	int i;
	char c2;
};
int main()
{
	printf("%d\n", offsetof(struct S1,c1));

	printf("%d\n", offsetof(struct S1,i));

	printf("%d\n", offsetof(struct S1,c2));

	return 0;
}

使用效果如下

以后計算結構體變數的大小也可以根據成員在結構體中偏移量的位置計算處結構體的大小，這樣也就更省事了

結構體傳參

struct S {
 int data[1000];
 int num;
};
struct S s = {{1,2,3,4}, 1000};
//結構體傳參
void print1(struct S s) {
 printf("%d\n", s.num);
}
//結構體地址傳參
void print2(const struct S* ps) {
 printf("%d\n", ps->num);
}
int main()
{
 print1(s);  //傳結構體
 print2(&s); //傳地址
 return 0; }

可以想的到出結構體傳參其實是有消耗的尤其是值傳遞，結構體成員越大，結構體變數的空間就占用的越多函式傳參的時候，引數是需要壓堆疊，會有時間和空間上的系統開銷，
如果傳遞一個結構體物件的時候，結構體過大，引數壓堆疊的的系統開銷比較大，所以會導致性能的下降
結論：結構體傳參，首選傳址

位段

位段的宣告和結構是類似的，有兩個不同：
1.位段的成員必須是 int、unsigned int 或signed int ，
2.位段的成員名后邊有一個冒號和一個數字，
3.使用位段可以節省空間哦

struct A {
 int _a:2;  //分配2個位元位
 int _b:5;	//分配5個位元位
 int _c:10; //分配10個位元位
 int _d:30; //分配30個位元位
};
printf("%d ",sizeof(struct A));

編譯器顯示的結果通過計算可以得出總的位元位是47 ，一個位元組是8個位元位，6個位元組也才48個位元位啊，而在使用sizeof計算的時候卻求得了8個位元組，可以看出即使是使用了位段，但是在實際中還是會浪費一定的空間，但是也明顯的節省了空間

來看這段代碼

struct S {
 char a:3;
 char b:4;
 char c:5;
 char d:4;
};
int main()
{
	struct S s = {0};
	s.a = 10; s.b = 12; s.c = 3; s.d = 4;
	printf("%d ",sizeof(struct S));
	return 0;
}

可以看出使用位段后明顯極大地節省了記憶體，原來應該是占用四個位元組，現在只需要占用3個位元組

進一步的分析你會知道它的內部原理

簡單理解就是每次都分配一個位元組的空間出去，不夠了再分配一個位元組的空間，而一個位元組恰好又是8個位元位，根據siezeof計算求出的結果可以知道是分配出去3個位元組的空間的，那么這3個位元組的空間又該怎么使用呢？

梳理一下采用位段分配方式后他們之間的記憶體布局關系

首先我們得求出各個成員變數的十進制數對應的二進制序列，當然這只是一部分

再將它們逐一擺放到對應的位置 ，到這里就得聯想我們之間的位段概念了，成員變數的位段有多大，那么分配數值的時候就會截取它對應的二進制序列的位數

截取之后的結果是這樣子的

最后再還原出來，
1、那么第一個位元組就是01100010對應的16進制數就是62
2、第二個位元組就是00000011對應的16進制數就是3
3、第三個位元組00000100對應的16進制數就是4

除錯運行后的結果，很明顯跟我們預期的結果是一樣的

位段的跨平臺問題

1. int 位段被當成有符號數還是無符號數是不確定的，
2. 位段中最大位的數目不能確定，（16位機器最大16，32位機器最大32，寫成27，在16位機器會出問題，
3. 位段中的成員在記憶體中從左向右分配，還是從右向左分配標準尚未定義，
4. 當一個結構包含兩個位段，第二個位段成員比較大，無法容納于第一個位段剩余的位時，是舍棄剩余的位
   還是利用，這是不確定的，

總結： 跟結構相比，位段可以達到同樣的效果，但是可以很好的節省空間，但是有跨平臺的問題存在， 位段的應用

位段的應用

有興趣的可以自行研究

列舉

• 列舉顧名思義就是一一列舉， 把可能的取值一一列舉， 比如我們現實生活中： 一周的星期一到星期日是有限的7天，可以一一列舉，
• 性別有：男、女、保密，也可以一一列舉， 月份有12個月，也可以一一列舉 顏色也可以一一列舉， 這里就可以使用列舉了

列舉型別的定義

enum Day//星期
{
 Mon,
 Tues,
 Wed,
 Thur,
 Fri,
 Sat,
 Sun
};

enum Sex//性別
{
 MALE,
 FEMALE,
 SECRET
};

• 以上定義的 enum Day ， enum Sex 都是列舉型別， {}中的內容是列舉型別的可能取值，也叫 列舉常 量 ，

• 這些可能取值都是有值的，默認從0開始，一次遞增1，當然在定義的時候也可以賦初值，

  列舉的使用

enum day//顏色
{ 
 Mon=1, 
 Tues=2, 
 Wed=3, 
}; 
enum day s1= Mon;//只能拿列舉常量給列舉變數賦值，才不會出現型別的差異，
s1 = 1; //ok??

注意在賦值的時候不要將一個整形值賦值給一個列舉型別的變數，如果是在.c檔案編譯的時候并不會出現明顯問題，但是換做.cpp檔案，那么編譯器就會毫不客氣地不讓你通過，這也屬于落型別語言的缺陷，修正方法是將列舉常量賦值給列舉變數

列舉的優點

• 我們可以使用 #define 定義常量，為什么非要使用列舉？ 列舉的優點：
  1. 增加代碼的可讀性和可維護性
  2. 和#define定義的識別符號比較列舉有型別檢查，更加嚴謹，
  3. 防止了命名污染（封裝）
  4. 便于除錯
  5. 使用方便，一次可以定義多個常量

聯合

聯合型別的定義

聯合型別的定義
聯合也是一種特殊的自定義型別 這種型別定義的變數也包含一系列的成員，特征是這些成員公用同一塊空間（所以
聯合也叫共用體）， 比如：

//聯合型別的宣告
union Un 
{ 
 char c; 
 int i; 
}; 
//聯合變數的定義
union Un un; 
//計算連個變數的大小
printf("%d\n", sizeof(un));

聯合的特點

• 聯合的成員是共用同一塊記憶體空間的，這樣一個聯合變數的大小，至少是最大成員的大小（因為聯合至少得有 能力保存最大的那個成員），

union Un 
{ 
 int i; 
 char c; 
}; 
union Un un; 
// 下面輸出的結果是一樣的嗎？
printf("%d\n", &(un.i)); 
printf("%d\n", &(un.c)); 
//下面輸出的結果是什么？
un.i = 0x11223344; 
un.c = 0x55; 
printf("%x\n", un.i);

由于聯合體 的成員是共用同一塊記憶體空間的，當這個聯合體變數被創建出來，它內部的成員地址都是一樣的，那么這個聯合體占用多大的空間呢，這是依據他最大成員的型別決定的，所以&(un.i)和&(un.c)的結果是一樣的

un.i = 0x11223344;
un.c = 0x55;
printf("%x\n", un.i);
再來看著一段代碼，你覺得結果會是什么呢？請把你的答案在心中默念一遍，這里直接借助除錯觀察
由于是小端存盤，所以它的低地址處會存放在低地址處，高地址會存放在高地址處，
當這句代碼一執行，可以看出它的低地址處發生了變化，因為un.c 成員是char型別,只占用一個位元組,對他已修改，直接導致結果變化
程式運行的結果

判斷機器是大端還是小端

思路：聯合體的成員都是共用同一塊記憶體的，那么只要將占用空間最大的那個成員初始化為1，那么就相當于將整個共用體的記憶體都給初始化了（00 00 00 01），再讓u.c去訪問這塊記憶體訪問的就是低地址處的01，就是1，小端存盤是低地址放在低地址處，高地址放在高地址處

union Un
{
	char c;
	int i;
};

int main()
{
	union Un u;
	u.i = 1;
	if (u.c)	
	{
		printf("小端\n");
	}
	else
		printf("大端\n");
	
	return 0;
}

聯合大小的計算

• 聯合的大小至少是最大成員的大小，
• 當最大成員大小不是最大對齊數的整數倍的時候，就要對齊到最大對齊數的整數倍，

union Un1 
{ 
 char c[5]; 
 int i; 
}; 
union Un2 
{ 
 short c[7]; 
 int i; 
}; 
//下面輸出的結果是什么？
printf("%d\n", sizeof(union Un1)); //8
printf("%d\n", sizeof(union Un2));//8

先看
union Un1
{
char c[5];
int i;
};
c的對齊數是1因為型別是char，而i的對齊數是4，因為型別是int，取對齊數4，所以聯合體的總大小必須是4的倍數，為陣列c分配的空間在0 ~ 4的范圍，分配出去5個位元組的空間，不是4的倍數，所以為了記憶體對齊會浪費3個位元組的空間，那么共用體的大小就是8，
union Un2
{
short c[7];
int i;
};
short型別大小是2位元組，int型別大小是4，取對齊數是4，陣列c占用的空間是2 * 7 = 14，并不是4的倍數，以為了記憶體對齊會浪費2個位元組的空間，那么共用體的大小就是16，

完