C語言知識總結(jié)——宏，枚舉，結(jié)構(gòu)體，共用體
1、#define宏定義
以#號開頭的都是編譯預處理指令，它們不是C語言的成分，但是C程序離不開它們，#define用來定義一個宏，程序在預處理階段將用define定義的來內(nèi)容進行了替換。因此在程序運行時，常量表中并沒有用define定義的常量，系統(tǒng)不為它分配內(nèi)存。define定義的常量，預處理時只是直接進行了替換，，它用來將一個標識符定義為一個字符串，該標識符被稱為宏名，被定義的字符串稱為替換文本。，因此在編譯時它不對宏的定義進行檢查，作用域不影響對常量的訪問 。它的常量值只能是字符串或數(shù)字。? ? ?該命令有兩種格式:一種是簡單的常量宏定義, 另一種是帶參數(shù)的宏定義。
不帶參數(shù)的宏：#define< 名字 >< 值 > ? ?要注意，沒有結(jié)尾的分號，因為不是C的語句，名字必須是一個單詞，值可以是各種東西，宏定義是用宏名來表示一個字符串，在宏展開時又以該字符串取代宏名，這只是一種簡單的代換，字符串中可以含任何字符，可以是常數(shù)，也可以是表達式，預處理程序?qū)λ蛔魅魏螜z查。如有錯誤，只能在編譯已被宏展開后的源程序時發(fā)現(xiàn)。
注意.宏定義不是說明或語句，在行末不必加分號，如加上分號則連分號也一起置換。宏定義其作用域為宏定義命令起到源程序結(jié)束。如要終止其作用域可使用#undef命令
帶參數(shù)的宏 ：? ? ?像函數(shù)的宏，一般的定義形式 ：帶參宏定義的一般形式為：**#define 宏名**（形參表）字符串，也是沒有結(jié)尾的分號，可以帶多個參數(shù) ，#define NB（a，b）((a)>(b)?(b):(a)), ?也可以組合（嵌套）使用其他宏，注意 帶參數(shù)宏的原則 一切都要有括號，參數(shù)出現(xiàn)的每個地方都要有括號。帶參數(shù)的宏在大型的程序的代碼中使用非常普遍，在#和##這兩個運算符的幫助下可以很復雜，如“產(chǎn)生函數(shù)”，但是有些宏會被inline函數(shù)代替（C++的函數(shù)）
使用宏好處：? ? ? “提高運行效”。定義的標識符不占內(nèi)存，只是一個臨時的符號，預編譯后這個符號就不存在了。在簡單的程序使用帶參數(shù)的宏定義可完成函數(shù)調(diào)用的功能，又能減少系統(tǒng)開銷，提高運行效率。正如C語言中所講，函數(shù)的使用可以使程序更加模塊化，便于組織，而且可重復利用。? ? ? “方便程序的修改”。使用宏定義可以用宏代替一個在程序中經(jīng)常使用的常量。注意，是“經(jīng)?！笔褂玫摹＿@樣，當需要改變這個常量的值時，就不需要對整個程序一個一個進行修改，只需修改宏定義中的常量即可。且當常量比較長時，使用宏就可以用較短的有意義的標識符來代替它，這樣編程的時候就會更方便，不容易出錯。因此，宏定義的優(yōu)點就是方便和易于維護。
//例子：/求球的體積
#include
#include
//對于半徑為?r?的球，其體積的計算公式為?V?=4/3*Π*r^3??
//這里取Π為3.14
//這里給定r的值，求V
#define?PI?3.14
int?main(void)?{
?double?r;
?scanf("%lf",?&r);
?double?sum?=?0;
?sum?=?(4.0?/?3.0)?*?PI*pow(r,?3);//這里用PI替換掉了?3.14
?printf("%f.2",?sum);
}
#include//合例子：輸入數(shù)字查看是星期幾
int?main(void)?{
?enum?week?{Mon?=?1,?Tue,?Wed,?Thu,?Fri,?Sat,?Sun}today;
?//在這里我們給Mon賦值了一，后面Tue以后的都相應(yīng)加一賦值
?scanf("%d",?&today);
?switch?(today)?{
?case?Mon:?puts("Monday");?break;
?case?Tue:?puts("Tuesday");?break;
?case?Wed:?puts("Wednesday");?break;
?case?Thu:?puts("Thursday");?break;
?case?Fri:?puts("Friday");?break;
?case?Sat:?puts("Saturday");?break;
?case?Sun:?puts("Sunday");?break;
?default:?puts("no?day");?
?}
?return?0;
}
2、enum枚舉
枚舉型是一個集合，集合中的元素(枚舉成員)是一些命名的整型常量，元素之間用逗號,隔開。它是一種用戶定義的數(shù)據(jù)類型，它用關(guān)鍵字enum以如下語法來聲明，：enum 枚舉類型名字，{名字0，...，名字n}；第一個枚舉成員的默認值為整型的0，后續(xù)枚舉成員的值在前一個成員上加1 （當然這個是可以自定義成員值的）
枚舉類型名字通常并不真的使用，要用的是在它大括號里邊的名字，因為它們就是常量符號，它們的類型是int，值則是依次從零到n，如 enum ?week { Monday,Tuoesday,Wedenday}; ?就創(chuàng)建了三個常量，Monday的值是0，Tuoesday是1，Wedenday是2，當需要一些可以可以排列起來的常量值的時候，定義枚舉的意義就是給了這些常量名字。雖然枚舉類型可以當類型使用，但是實際上并不常用，但是如果是有意是排比名字，用枚舉比宏定義方便，枚舉比用好些，因為枚舉有int類型，在C 語言中，枚舉類型是被當做 int 或者 unsigned int 類型來處理的，既然枚舉也是一種數(shù)據(jù)類型，所以它和基本數(shù)據(jù)類型一樣也可以對變量進行聲明，枚舉也可以用typedef關(guān)鍵字將枚舉類型定義成別名，并利用該別名進行變量聲明
注意：1、同一個程序中不能定義同名的枚舉類型，不同的枚舉類型中也不能存在同名的命名常量
2、枚舉成員）是「常量」而不是變量，這個一定要搞清楚，因為枚舉成員的是常量，所以不能對它們賦值，只能將它們的值賦給其他的變量
3、枚舉類型的定義和變量的聲明分開：如果對枚舉型的變量賦整數(shù)值時，需要進行類型轉(zhuǎn)換
enum?DAY?{?MON=1,?TUE,?WED,?THU,?FRI,?SAT,?SUN?};//枚舉常量的值是可以在這里進行自定義的??MON=1
//基本數(shù)據(jù)類型的賦值??：?
?int?a,?b,?c;???????
?a?=?1;???????
??b?=?2;??
??c?=?3;???
??//使用枚舉賦值???：
?enum?DAY?yesterday,?today,?tomorrow;//枚舉定義變量???????
?yesterday?=?MON;??
??today?????=?TUE;???
?tomorrow??=?WED;
//??today?=?(enum?DAY)?(yesterday?+?1);//強制類型轉(zhuǎn)換
//??tomorrow?=?(enum?DAY)?30;?
//強制類型轉(zhuǎn)換//tomorrow?=?3;?//錯誤
枚舉在用switch-case結(jié)構(gòu)中使用非常方便.
//綜合例子：輸入數(shù)字查看是星期幾
#include?//枚舉是define的代替??它是一個集合??//和switch連用很方便
int?main()?{
????
?enum??week?{?Mon?=?1,Tues,?Wed,?Thurs,?Fri,?Sat,?Sun?}?day;??//day可放到這
?//enum?week?day;定義
?scanf("%d",?&day);
?switch?(day)?{
?case?Mon:?puts("Monday");?break;//1??puts代替printf輸出字符串
?case?Tues:?puts("Tuesday");?break;//?2
?case?Wed:?puts("Wednesday");?break;//?3
?case?Thurs:?puts("Thursday");?break;//?4
?case?Fri:?puts("Friday");?break;//?5
?case?Sat:?puts("Saturday");?break;//?6
?case?Sun:?puts("Sunday");?break;//?7
?default:?puts("Error!");
?}
?return?0;
}
枚舉型是預處理指令#define的替代，枚舉和宏其實非常類似，宏在「預處理階段」將名字替換成對應(yīng)的值，枚舉在「編譯階段」將名字替換成對應(yīng)的值，其中一個枚舉常量的占的字節(jié)數(shù)為4個字節(jié)，恰好和int類型的變量占的字節(jié)數(shù)相同
3、struct 結(jié)構(gòu)體
struct即結(jié)構(gòu)體，C程序中經(jīng)常需要用相關(guān)的不同類型的數(shù)據(jù)來描述一個數(shù)據(jù)對象。例如，描述學生的綜合信息時，需要使用學生的學號、姓名、性別等不同類型的數(shù)據(jù)時，像這種數(shù)據(jù)類型總是在一起出現(xiàn)，那么我們不如把這些變量裝入同一個“文件夾”中，這時用的關(guān)鍵字struct聲明的一種數(shù)據(jù)類型就是表示這個“文件夾”的使用。那么在說明和使用之前必須先定義它，也就是構(gòu)造它。如同在說明和調(diào)用函數(shù)之前要先定義一樣。結(jié)構(gòu)體是一種集合，它里面包含了多個變量或數(shù)組，它們的類型可以相同，也可以不同，每個這樣的變量或數(shù)組都稱為結(jié)構(gòu)體的成員，結(jié)構(gòu)體也是一種數(shù)據(jù)類型，它由程序員自己定義，可以包含多個其他類型的數(shù)據(jù)，成員又稱為成員變量，它是結(jié)構(gòu)體所包含的若干個基本的結(jié)構(gòu)類型，必須用“{}”括起來，并且要以分號結(jié)束，每個成員應(yīng)表明具體的數(shù)據(jù)類型，成員一般用名字訪問。結(jié)構(gòu)體和數(shù)組類似，也是一組數(shù)據(jù)的集合，整體使用沒有太大的意義。數(shù)組使用下標[ ]獲訪問元素，結(jié)構(gòu)體使用點號.訪問單個成員。通過這種方式可以獲取成員的值，也可以給成員賦值
數(shù)組：a[0]=10; ? 結(jié)構(gòu)體：today.day ?(指針結(jié)構(gòu)體用->訪問) 結(jié)構(gòu)體的成員可以包含其他結(jié)構(gòu)體，也可以包含指向自己結(jié)構(gòu)體類型的指針，而通常這種指針的應(yīng)用是為了實現(xiàn)一些更高級的數(shù)據(jù)結(jié)構(gòu)如鏈表和樹等。
聲明定義結(jié)構(gòu)：
struct關(guān)鍵字+結(jié)構(gòu)體的標志名+大括號里邊是成員+}后面的聲明此結(jié)構(gòu)變量+末尾分號，一般有這些：
struct?week{定義一????????????????struct{定義二?????????????????????struct?week?{定義三
int?x;????int?x;??????int?x;
char?y;????char?y;??????int?y;
};????}p1,p2;//在這里聲明變量???}p1,p2;
????//p1和p2都是一種無名結(jié)構(gòu)，??//常用的一種結(jié)構(gòu)定義聲
struct?week?p1,p2;??//?里邊有X和y?訪問一樣用.???明形式?
//聲明變量p1,p2,里邊都是week的值?????
//里邊有x和y的值????????
//用.訪問?：p1.x p2.x ?????
?//????p1.y,?p2.y?????
對于第一和第三種形式，都聲明了結(jié)構(gòu)名week，但是第二種沒有聲明結(jié)構(gòu)名,只是定義了兩個結(jié)構(gòu)變量，
這種叫無名結(jié)構(gòu)
無名結(jié)構(gòu)：?可以定義無名結(jié)構(gòu)體類型的變量。編譯器對無名結(jié)構(gòu)體的處理是隨機生成一個不重復的變量名。
無名結(jié)構(gòu)的定義方式就是定義無名結(jié)構(gòu)體時必須定義該結(jié)構(gòu)體類型的至少一個變量。
優(yōu)點：無名結(jié)構(gòu)體的妙用就是可以避免相同類型的結(jié)構(gòu)體的重復定義，
這樣可以對每一個具體類型的隊列都可以定義一個結(jié)構(gòu)體來管理該隊列的頭尾指針，
即使定義多個相同具體類型的隊列也不會引發(fā)重復定義的編譯錯誤。這樣定義了兩個隊列，
其元素類型均為int類型，同時各得到了一個維護隊列頭尾指針的結(jié)構(gòu)體
缺點：這里定義了一個無名的結(jié)構(gòu)體，同時聲明了三個此種類型的變量。
但是，因為沒有名字，我們在這句之后，無法內(nèi)再定義與那三種變量相同類型的變量了。
除非你再容次去定義一個這樣的相同的結(jié)構(gòu)體類型。
還有一個重要的原因就是沒有辦法在其他位置定義我們所需要的結(jié)構(gòu)體變量，
每次需要新定義結(jié)構(gòu)體變量的時候都必須要找到最開始結(jié)構(gòu)體代碼書寫的位置才能定義新的結(jié)構(gòu)體?
?
所以實際編程中無名結(jié)構(gòu)并不常用?????????????
注意：1、結(jié)構(gòu)體本身并不會被作為數(shù)據(jù)而開辟內(nèi)存，真正作為數(shù)據(jù)而在內(nèi)存中存儲的是這種結(jié)構(gòu)體所定義的變量。
2、先聲明結(jié)構(gòu)體類型，再定義該類型的變量，聲明結(jié)構(gòu)體類型，不分配空間定義結(jié)構(gòu)體類型變量，就要分配內(nèi)存空間
3、量使用占為少的類型,如,在可能的時候使用short代替int，「按數(shù)據(jù)類型本身占用的位置從大到小排」
4、除了可以對成員進行逐一賦值，也可以在定義時整體賦值：p1={struct week}{5,10}; 相當于 p1.x=5,p1.y=10; p1=p2 表示 p1.x=p2.x , ?p1.y=p2.y; 不過整體賦值僅限于定義結(jié)構(gòu)體變量的時候，在使用過程中只能對成員逐一賦值 5、結(jié)構(gòu)體變量不能相加，相減，也不能相互乘除，但結(jié)構(gòu)體可以相互賦值，也就是說，可以將一個結(jié)構(gòu)體變量賦值給另一個結(jié)構(gòu)體變量。但是前提是這兩個結(jié)構(gòu)體變量的結(jié)構(gòu)體類型必須相同
結(jié)構(gòu)體的運算：要訪問整個結(jié)構(gòu)，直接用結(jié)構(gòu)變量的名字，對于整個結(jié)構(gòu)，可以做賦值，取地址，也可以傳遞給函數(shù)參數(shù)
結(jié)構(gòu)體數(shù)值
嵌套的結(jié)構(gòu)體：
struct?week{
int?x;
int?y;
strcut?week?at;//在結(jié)構(gòu)體又定義了名為at的一個和week同樣參數(shù)的結(jié)構(gòu)體變量
????//其中可以用.運算符訪問??see.at.x?see.at.y
}see;
但是其實這樣的方式是不建議（非法）的，因為這種聲明實際上是一個無限循環(huán)，成員at是一個結(jié)構(gòu)體，
at的內(nèi)部還會有成員是結(jié)構(gòu)體，依次下去，無線循環(huán)。在分配內(nèi)存的時候，由于無限嵌套，
也無法確定這個結(jié)構(gòu)體的長度，所以這種方式是非法的
正確的方式是使用《結(jié)構(gòu)體指針》，因為指針的長度是確定的:
struct?week{
int?x;
int?y;
strcut?week?*at;//在結(jié)構(gòu)體內(nèi)定義了一個指向和week一樣類型的結(jié)構(gòu)指針
}see;??????????但是注意用指針訪問時要用->運算符???see.at->x
結(jié)構(gòu)體相互引用：
一個結(jié)構(gòu)體A中包含一個或多個與結(jié)構(gòu)體B相關(guān)的成員, 且結(jié)構(gòu)體B中也包含一個或多個與結(jié)構(gòu)體A相關(guān)的成員稱為結(jié)構(gòu)體的互引用. ?但是要注意：如果已經(jīng)定義了兩個結(jié)構(gòu)A和B ，在定義結(jié)構(gòu)體A的成員b時，結(jié)構(gòu)體B對A還未可見，故此時編譯器會報數(shù)據(jù)類型B未定義 解決的辦法是使用不完整聲明：
strcut?A;//不完整聲明
strcut?B;//不完整聲明
strcut?_A{???????????????strcut?_B{
int?x;?????int?x;
int?y;???????????????int?y;
struct?_B?a;????struct?_A?b;??//在結(jié)構(gòu)B中定義了一個名為b的和A結(jié)構(gòu)一樣類型的結(jié)構(gòu)變量
?????????????//其中可以用點訪問?A.a.x???B.b.x
}A；??????????????????????}B；
//但是注意這種方式犯了一個和上面第一個嵌套結(jié)構(gòu)的錯誤，就是結(jié)構(gòu)體A和B都是直接包含了對方，
正確的用法還是使用指針：
strcut?_A{???????????????strcut?_B{
int?x;?????int?x;
int?y;???????????????int?y;
struct?_B?*a;???struct?_A?*b;??//在結(jié)構(gòu)B中定義了一個名為b的和A結(jié)構(gòu)一樣類型的結(jié)構(gòu)指針
???????????????????//其中指針要用->訪問?A.a->x???B.b->x
}A；?????????????????????????????????}B；?
//但是注意這種方式犯了一個和上面第一個嵌套結(jié)構(gòu)的錯誤，就是結(jié)構(gòu)體A和B都是直接包含了對方，正確的用法還是使用指針：
strcut?_A{???????????????strcut?_B{
int?x;???????????int?x;
int?y;???????????????int?y;
struct?_B?*a;?????struct?_A?*b;??//在結(jié)構(gòu)B中定義了一個名為b的和A結(jié)構(gòu)一樣類型的結(jié)構(gòu)指針
?????????????//其中指針要用->訪問?A.a->x???B.b->x
}A；????????????????????????????????}B；
//所以使用互引用要注意：至少有一個結(jié)構(gòu)必須在另一個結(jié)構(gòu)體中以指針的形式被引用。
結(jié)構(gòu)體函數(shù)與函數(shù)參數(shù)
結(jié)構(gòu)體做函數(shù)形參：
整個結(jié)構(gòu)可以作為參數(shù)的值傳入函數(shù)，這時候是在函數(shù)內(nèi)新建一個結(jié)構(gòu)變量，并復制調(diào)用者結(jié)構(gòu)的值，也可以返回一個值，這和數(shù)組完全不同 用結(jié)構(gòu)體變量作實參時，采取的也是“值傳遞”方式，將 ?結(jié)構(gòu)體變量所占的內(nèi)存單元的內(nèi)容（結(jié)構(gòu)體變量成員列表） ? 全部順序傳遞給形參，這里形參也得是結(jié)構(gòu)體變量。
#include
typedef?struct?_node?{
?int?n;
?char?a[100];
}NODE;
void?add(NODE?a);//這種形式只是用來做值的傳遞
int?main(void)?{
?//以傳值方式傳遞結(jié)構(gòu)需要對整個結(jié)構(gòu)做一份拷貝
?NODE?t;
?scanf("%d?%d",?&t.a[0],?&t.n);//輸入1??3
?printf("1-%d?%d\n",t.a[0],t.n);//輸出?1???3
?add(t);
?printf("3-%d?%d\n",?t.a[0],?t.n);//輸出1??3
//也就是說在add函數(shù)里邊做修改根本就影響不了主函數(shù)這邊的值
}
void?add(NODE?a)?{
?a.a[0]?=?100;//在這里能接受到NODE結(jié)構(gòu)里邊的成員
?a.n?=?666;
?printf("2-%d?%d\n",?a.a[0],?a.n);//輸出100???666
}
?****//解決辦法是用指針（也是經(jīng)常用的方式）：****
#include
typedef?struct?_node?{
?int?n;
?char?a[100];
}NODE;
int??add(NODE?a);//這種形式只是用來做值的傳遞
int?main(void)?{
?//以傳值方式傳遞結(jié)構(gòu)需要對整個結(jié)構(gòu)做一份拷貝
?NODE?t;
?scanf("%d?%d",?&t.a[0],?&t.n);//輸入1??3
?printf("1-%d?%d\n",t.a[0],t.n);//輸出?1???3
?add(&t);//這里傳進去的是t的地址
?printf("3-%d?%d\n",?t.a[0],?t.n);//輸出100??666
//傳進去的是地址，所以就可以達到訪問同一個變量的操作
}
int??add(NODE?*)?{//定義一個結(jié)構(gòu)指針
?a.a[0]?=?100;//在這里能接受到NODE結(jié)構(gòu)里邊的成員
?a.n?=?666;
?printf("2-%d?%d\n",?a.a[0],?a.n);//輸出100???666
?return?a;//這里返回的是指針??所以能達到訪問主函數(shù)里邊調(diào)用的值
?//使用指針才可以用返回值
}
//常用的方式
另一種做法
結(jié)構(gòu)體做函數(shù)：
/*上面的第一個的方案，把一個結(jié)構(gòu)傳入了函數(shù)，然后在函數(shù)中操作，但是沒有返回回去
問題在于傳入函數(shù)的是外面那個結(jié)構(gòu)的克隆體，而不是指針，傳入結(jié)構(gòu)和傳入數(shù)組是不同的，
解決辦法是在這個輸入函數(shù)中，在里邊創(chuàng)建一個臨時的結(jié)構(gòu)變量，然后把這個結(jié)構(gòu)返回給調(diào)用者*/
#include
typedef?struct?_node?{
?int?x;
?int?y;
}NODE;
struct?_node?add();//定義結(jié)構(gòu)類型的函數(shù)
int?main(void)?{
?NODE?a;
?a.x?=?0;
?a.y?=?0;
?printf("1-%d?%d\n",?a.x,?a.y);//???0?0
?a?=?add();//函數(shù)調(diào)用???/把n的值又返回到a
?printf("3-%d?%d\n",?a.x,?a.y);//所以在這里的時候值已經(jīng)被改變
?return?0;
}
struct?_node?add()?{
?NODE?n;
?scanf("%d",?&n.x);//輸入1??3
?scanf("%d",?&n.y);
?printf("2-%d?%d\n",?n.x,?n.y);//在這里的時候賦值就成功了
?//return?n;//把n的值帶回出去
}
//這種方法也能達到“改變"的效果，但是往往開銷內(nèi)存較大，所以一般情況都是使用指針比較方便
用結(jié)構(gòu)體變量名作參數(shù)，這種傳遞方式是單向的，如果在執(zhí)行被調(diào)函數(shù)期間改變了形參（也是結(jié)構(gòu)體變量）的值，該值不能返回主調(diào)函數(shù)，這往往造成使用上的不便，因此一般少用這種方法。
和本地變量一樣。在函數(shù)內(nèi)部聲明的結(jié)構(gòu)只能在函數(shù)內(nèi)部使用，所以通常在函數(shù)外部聲明一個結(jié)構(gòu)類型的，這樣就可以被多個函數(shù)所使用
//結(jié)構(gòu)做函數(shù)參數(shù)例子?（輸入今天計算明天）
#include
#include//利用布爾數(shù)據(jù)類型
struct?date?{
?int?year;
?int?month;
?int?day;
};
bool?If(struct?date?p);//判斷是否是閏年
int?number(struct?date?c);//判斷是否是此月最后一天
int?main(void)?{
?struct?date?today,tomorrow;
?printf("年-月-日\n");
?scanf("%d?%d?%d",?&today.year,?&today.month,?&today.day);
?//前面兩個判斷?是否此月最后一天??是否此年此月最后一天??
?if?(today.day==number(today)&&today.month!=12)?{//首月1號
??tomorrow.day?=?1;
??tomorrow.month?=today.month+1;
??tomorrow.year?=?today.year;
?}
?else?if?(today.day?==?number(today)?&&?today.month?==?12)?{//下一年
??tomorrow.day?=?1;
??tomorrow.month?=?1;
??tomorrow.year?=today.year+1;
?}
?else?{
??tomorrow.day?=today.day+1;
??tomorrow.month?=?today.month;
??tomorrow.year?=?today.year;
?}
?printf("明天是%d-%d-%d\n",?tomorrow.year,?tomorrow.month,?tomorrow.day);
?return?0;
}
int?number(struct?date?c)//這里的形參接收的today結(jié)構(gòu)體數(shù)據(jù)
{
?int?day;
?const?int?a[12]?=?{?31,28,31,30,31,30,31,31,30,31,30,31?};//這個月最大的天數(shù)
?if?(c.month==22&&If(c))?{//查看是否是二月并且是潤年
??day?=?29;//是潤年
?}
?else?{
??day?=?a[c.month?-?1];
?}
?return?day;
}
bool?If(struct?date?p)?{//這里的形參接收的today結(jié)構(gòu)體數(shù)據(jù)
?//潤年的特點，能被4整除，但不能被100整數(shù)，能被100整除，但是不能被400整除
?if?(p.year?%?4?==?0?&&?p.year?/?100?!=?0?||?p.year?%?400?==?0)?{
??return?true;
?}
?else?{
??return?false;
?}
}
//結(jié)構(gòu)體做函數(shù)例子?（計算下一秒）
#include
struct?time?{
?int?hour;
?int?minute;
?int?second;
};
struct?time?times(struct?time?now);//利用結(jié)構(gòu)做函數(shù)返回值，形參也是使用結(jié)構(gòu)體做為傳值
int?main(void)?{
?struct?time?nows[5]?=?{
??{11,50,20},{13,25,59},{12,59,59},{23,59,59},{00,00,00},
?};
?int?i;
?for?(i?=?0;?i?5;?i++)?{
??printf("時間是?%d:%d:%d\n",?nows[i].hour,?nows[i].minute,?nows[i].second);
??nows[i]?=?times(nows[i]);
??printf("下一秒是?%d:%d:%d\n",?nows[i].hour,?nows[i].minute,?nows[i].second);
?}
?return?0;
}
struct?time?times(struct?time?now)?{
?now.second++;
?if?(now.second?==?60)?{//60秒
??now.minute++;
??now.second?=?0;
??if?(now.minute?==?60)//60分
??{
???now.hour++;
???now.minute?=?0;
???now.second?=?0;
???if?(now.hour?==?24)?{//零點
????now.hour=0;
????now.minute?=?0;
????now.second?=?0;
???}
??}
?}
?return?now;//返回類型必須也函數(shù)類型一致，換句話說只有結(jié)構(gòu)體類型才能返回結(jié)構(gòu)體類型
}
結(jié)構(gòu)體數(shù)組
結(jié)構(gòu)體數(shù)組，是指數(shù)組中的每個元素都是一個結(jié)構(gòu)體。在實際應(yīng)用中，C語言結(jié)構(gòu)體數(shù)組常被用來表示一個擁有相同數(shù)據(jù)結(jié)構(gòu)的群體，比如一個班的學生、一個車間的職工等。結(jié)構(gòu)體可以存儲不同的數(shù)據(jù)類型，將他們互相聯(lián)系起來。結(jié)構(gòu)體數(shù)組可以連續(xù)存儲多個結(jié)構(gòu)體，和數(shù)組作用相似。比如想定義同一個最小外接矩形的四個坐標值，并給予這個矩形一個特征編號。當需要存儲多個最小外接矩形的信息時，就需要動態(tài)申請一個結(jié)構(gòu)體數(shù)組
定義結(jié)構(gòu)體數(shù)組的方法很簡單，同定義結(jié)構(gòu)體變量是一樣的，只不過將變量改成數(shù)組。或者說同前面介紹的普通數(shù)組的定義是一模一樣的：struct student ?tp[10]; 這就定義了一個結(jié)構(gòu)體數(shù)組，共有 10 個元素，每個元素都是一個結(jié)構(gòu)體變量，都包含所有的結(jié)構(gòu)體成員。
結(jié)構(gòu)體數(shù)組的初始化與前面講的數(shù)值型數(shù)組的初始化也是一樣的，數(shù)值型數(shù)組初始化的方法和需要注意的問題在結(jié)構(gòu)體數(shù)組的初始化中同樣適用，因為不管是數(shù)值型數(shù)組還是結(jié)構(gòu)體數(shù)組都是數(shù)組。
//例子：??//尋找學生中?學號最大的
#?include?
#?include?
struct?STU
{
?char?name[20];
?int?age;
?char?sex[20];
?char?num[20];
};
void?OutputSTU(struct?STU?stu[]);??//函數(shù)聲明,?該函數(shù)的功能是輸出成績最大的學生信息
int?main(void)
{
?int?i;
?struct?STU?stu[5];
?for?(i?=?0;?i?2;?++i)
?{
??printf("請按照名字、年齡、性別、學號(1-9數(shù)字）輸入第%d個學生的信息:",?i?+?1);
??scanf("%s?%d?%s?%s",?stu[i].name,?&stu[i].age,?stu[i].sex,?stu[i].num);/*%c前面要加空格,?不然輸入時會將空格賦給%c*/
?}
?OutputSTU(stu);
?return?0;
}
void?OutputSTU(struct?STU?stu[])
{
?struct?STU?stumax?=?stu[0];//讓臨時結(jié)構(gòu)stumax保存第一個學生的信息
?int?j;
?for?(j?=?1;?j?2;?++j)//第一個學生依次和后面的學生比較
?{
??if?(strcmp(stumax.num,?stu[j].num)?0)??//strcmp函數(shù)的使用??s1>s2:1???s1
??{
???stumax?=?stu[j];//讓臨時結(jié)構(gòu)保存那個學生的信息
??}
?}
?printf("學生姓名：%s 學生年齡：%d 學生性別：%s 學生分數(shù)：%s\n",?stumax.name,?stumax.age,?stumax.sex,?stumax.num);
}
結(jié)構(gòu)體指針
和數(shù)組不同，結(jié)構(gòu)變量的名字并不是結(jié)構(gòu)變量的地址，必須使用&運算符 ?strcut node *tp=&nb; ?指針一般用->訪問結(jié)構(gòu)體里邊的成員
指針變量非常靈活方便，可以指向任一類型的變量 ? ?，若定義指針變量指向結(jié)構(gòu)體類型變量，則可以通過指針來引用結(jié)構(gòu)體類型變量。
#include
struct?node{
int?x;
int?y;
}my;
int?main(void)?{
?struct?node?*p?=?&my;//定義了一個指針p指向了my的結(jié)構(gòu)體
?p->x?=?11;//這是一種訪問方式（常用的方式）
?(*p).x?=?12;//這是第二種方式，
?printf("%d",?p->x);//輸出是12
}
以下?2?種形式是等價的：
(*指針變量).成員名。
指針變量->成員名。
其中第?2?種方式很重要，通常都是使用這種方式，另外兩種方式用得不多。
后面講鏈表的時候用的也都是第?3?種方式。
這里說明：結(jié)構(gòu)體和結(jié)構(gòu)體變量是兩個不同的概念：結(jié)構(gòu)體是一種數(shù)據(jù)類型，是一種創(chuàng)建變量的模板，編譯器不會為它分配內(nèi)存空間，就像 int、float、char 這些關(guān)鍵字本身不占用內(nèi)存一樣；結(jié)構(gòu)體變量才包含實實在在的數(shù)據(jù)，才需要內(nèi)存來存儲。所以用一個結(jié)構(gòu)體去取一個結(jié)構(gòu)體名的地址，這種寫法是錯誤的，也不能將它賦值給其他變量。
#include
struct?point?{
?int?x;
?int?y;
};
struct?point?*gt(struct?point*p);//結(jié)構(gòu)指針函數(shù)
void??print(const?struct?point?*p);//結(jié)構(gòu)指針
void?out(struct?point?p);//普通的結(jié)構(gòu)體做函數(shù)參數(shù)
int?main(void)?{
?struct?point?y?=?{?0,0?};//以point結(jié)構(gòu)定義一個y的結(jié)構(gòu)變量
?//以下三種調(diào)用??等價
?//注意gt是一個結(jié)構(gòu)體的指針函數(shù)
?gt(&y);?//這是一個函數(shù)的返回結(jié)果函數(shù)??//取y結(jié)構(gòu)的地址傳入函數(shù)
?out(y);
?out(*gt(&y));???//?（里邊）的都是做為參數(shù)??*gt(&y)做為指針返回值??這個函數(shù)它的返回用指針表示
?print(gt(&y));??//gt(&y)是一個返回值???這樣表示的是利用gt函數(shù)的返回值在print函數(shù)里邊操作
?//*get(&y)?=?(struct?point){?1,2?};??//這也可以做的
}
struct?point*?gt(struct?point*p)?{//?*p要的是&y的地址
?
?scanf("%d",?&p->x);
?scanf("%d",?&p->y);
?printf("a=%d,%d?\n",?p->x,?p->y);//用->來訪問指針結(jié)構(gòu)里邊的成員
?return?p;//?用完指針后?返回指針
}
void?out(struct?point?p)?{
?printf("b=%d,%d\n",?p.x,?p.y);
}
void?print(const?struct?point?*p)?{//加上const表示不再改動參數(shù)
?printf("c=%d,%d\n",?p->x,?p->y);
}
指向結(jié)構(gòu)體數(shù)組的指針：
在之前講數(shù)值型數(shù)組的時候可以將數(shù)組名賦給一個指針變量，從而使該指針變量指向數(shù)組的首地址，然后用指針訪問數(shù)組的元素。結(jié)構(gòu)體數(shù)組也是數(shù)組，所以同樣可以這么做。
我們知道，結(jié)構(gòu)體數(shù)組的每一個元素都是一個結(jié)構(gòu)體變量。如果定義一個結(jié)構(gòu)體指針變量并把結(jié)構(gòu)體數(shù)組的數(shù)組名賦給這個指針變量的話，就意味著將結(jié)構(gòu)體數(shù)組的第一個元素，即第一個結(jié)構(gòu)體變量的地址，也即第一個結(jié)構(gòu)變量中的第一個成員的地址賦給了這個指針變量
#?include?
struct?qt
{
?char?name[5];
?int?age;
?char?sex[5];
?double?scroe;
};
int?main(void)
{????//定義了一個student的結(jié)構(gòu)數(shù)組
?struct?qt?student[5]?=?{?{"李青",?20,?"男",?99},?{"黃歡",?20,??"女",?80},?{"七七",?23,?"男",?95}?};
?struct?qt?*p?=?student;
?int?i;
?for?(i?=?0;?i?5;?i++)?{
??printf("%s?",?p->name);//利用->可訪問成員（訪問意味著可以讀寫）
??printf("%d?",?p->age);
??printf("%s?",?p->sex);
??printf("%f?",?p->scroe);
?}
?return?0;
}
當結(jié)構(gòu)體指針變量指向一個結(jié)構(gòu)體變量數(shù)組的時候，此時指針變量的值就是結(jié)構(gòu)體數(shù)組的首地址,
此時指針變量?p?就指向了結(jié)構(gòu)體數(shù)組的第一個元素，即指向?student[0]。我們知道，
當一個指針指向一個數(shù)組后，指針就可以通過移動的方式指向數(shù)組的其他元素。
這個原則對結(jié)構(gòu)體數(shù)組和結(jié)構(gòu)體指針同樣適用，所以?p?+?1?就指向?student[1]?的首地址；p +?2?就指向?
student[2]?的首地址……所以只要利用?for?循環(huán)，指針就能一個個地指向結(jié)構(gòu)體數(shù)組元素。
同樣需要注意的是，要將一個結(jié)構(gòu)體數(shù)組名賦給一個結(jié)構(gòu)體指針變量，那么它們的結(jié)構(gòu)體類型必須相同。
typedef 別名
typedef是在編程語言中用來為復雜的聲明定義簡單的別名，新的名字是某種類型的別名，這樣做改善了程序的可讀性，它與宏定義有些差異。它本身是一種存儲類的關(guān)鍵字，與auto、extern、mutable、static、register等關(guān)鍵字不能出現(xiàn)在同一個表達式中。
typedef為C語言的關(guān)鍵字，功能是用來聲明一個已有的數(shù)據(jù)類型的新名字，比如 typedef int last ; ?這就使得last成為 int 類型的別名 ?這樣last這個名字就可以代替int出現(xiàn)在變量定義和參數(shù)聲明的地方了
typedef也有一個特別的長處：它符合范圍規(guī)則，使用typedef定義的變量類型其作用范圍限制在所定義的函數(shù)或者文件內(nèi)（取決于此變量定義的位置），而宏定義則沒有這種特性。
typedef?&?復雜的變量聲明
理解復雜聲明可用的“右左法則”：
??從變量名看起，先往右，再往左，碰到一個圓括號就調(diào)轉(zhuǎn)閱讀的方向；括號內(nèi)分析完就跳出括號，
還是按先右后左的順序，如此循環(huán)，直到整個聲明分析完。舉例：
??int?(*func)(int?*p);
??首?先找到變量名func，外面有一對圓括號，而且左邊是一個*號，這說明func是一個指針；
然后跳出這個圓括號，先看右邊，又遇到圓括號（只有函數(shù)后面才跟形參圓括號），
這說明?(*func)是一個函數(shù)，所以func是一個指向這類函數(shù)的指針，即函數(shù)指針，
這類函數(shù)具有int*類型的形參，返回值類型是int，此處就是聲明函數(shù)。
??int?(*func[5])(int?*);
??func?右邊是一個[]運算符，說明func是具有5個元素的數(shù)組；func的左邊有一個*，
說明func的元素是指針（注意這里的*不是修飾func，而是修飾?func[5]的，原因是[]運算符優(yōu)先級比*高，
func先跟[]結(jié)合）。跳出這個括號，看右邊，又遇到圓括號，說明func數(shù)組的元素是函數(shù)類型的指?針，
它指向的函數(shù)具有int*類型的形參，返回值類型為int。
也可以記住2個模式：
type?(*)(....)函數(shù)指針
type?(*)[]數(shù)組指針復制代碼
結(jié)構(gòu)體的內(nèi)存對齊方式（存儲空間）
結(jié)構(gòu)體內(nèi)存對齊：一個結(jié)構(gòu)體變量定義完之后，其在內(nèi)存中的存儲并不等于其所包含元素的寬度之和，元素是按照定義順序一個一個放到內(nèi)存中去的，但并不是緊密排列的。從結(jié)構(gòu)體存儲的首地址開始，每個元素放置到內(nèi)存中時，它都會認為內(nèi)存是按照自己的大小來劃分的，因此元素放置的位置一定會在自己寬度的整數(shù)倍上開始。
內(nèi)存對齊可以大大提升內(nèi)存訪問速度，是一種用空間換時間的方法。內(nèi)存不對齊會導致每次讀取數(shù)據(jù)都會讀取兩次，使得內(nèi)存讀取速度減慢。
cpu把內(nèi)存當成是一塊一塊的，塊的大小可以是2,4,8,16 個字節(jié)，因此CPU在讀取內(nèi)存的時候是一塊一塊進行讀取的，塊的大小稱為內(nèi)存讀取粒度。
//?內(nèi)存對齊原則：
//???1、第一個成員的首地址為0.
//???2、每個成員的首地址是自身大小的整數(shù)倍
//??? 3、結(jié)構(gòu)體的總大小，為其成員中所含最大類型的整數(shù)倍。
#include
typedef?struct?_node?{
?//char?t;//1
?//int?p;?//4
?//float?y;//8
//char?t?要存放的偏移量為0，滿足對齊方式，t占用一個字節(jié)，
int?p要存儲在下一個可用的地址的偏移量為1.不是sizeof(int)=4的倍數(shù)，
需要補足3個字節(jié)才能使偏移量變?yōu)?span style="color: #d19a66;line-height: 26px;">4(使其滿足對齊方式)，因此系統(tǒng)自動填充3個字節(jié)使偏移量增加到4，
int?p放到此位置，占用4個字節(jié)，下一可用的偏移量為8，滿足sizeof(float）=4的對齊，
所以float?y直接存放在偏移量為8的位置上，它占用4個字節(jié)??總共就是?//1+3+4+4=12
?double?a;//8
?char?b;//1
?int?c;//4
//double?a的要存放的偏移量為0，滿足對齊方式直接存儲，占用8個字節(jié)，
char?b要存儲在下一的可用的地址的偏移量為9，
直接存儲，占用字節(jié)為1；int?c要存儲在下一個可用的地址的偏移量為9，
9不滿足sizeof（int）=4;所以系統(tǒng)會自動分配3的字節(jié)增加到12，12滿足對齊方式，
存儲下去c占用4個字節(jié)?？偣簿褪???//8+1+3+4=16
}NODE;
int?main(void)?{
?printf("%d?",?sizeof(NODE));
}
如果結(jié)構(gòu)體內(nèi)存在長度大于處理器位數(shù)的元素，那么就以處理器的倍數(shù)為對齊單位；否則，如果結(jié)構(gòu)體內(nèi)的元素的長度都小于處理器的倍數(shù)的時候，便以結(jié)構(gòu)體里面最長的數(shù)據(jù)元素為對齊單位。
另外 ?結(jié)構(gòu)體的內(nèi)存地址就是它第一個成員變量的地址 ?isa永遠都是結(jié)構(gòu)體中的第一個成員變量 ?所以結(jié)構(gòu)體的地址也就是其isa指針的地址
內(nèi)存對齊簡介
由于內(nèi)存的讀取時間遠遠小于CPU的存儲速度，這里用設(shè)定數(shù)據(jù)結(jié)構(gòu)的對齊系數(shù)，即犧牲空間來換取時間的思想來提高CPU的存儲效率。
內(nèi)存對齊”應(yīng)該是編譯器的“管轄范圍”。編譯器為程序中的每個“數(shù)據(jù)單元”安排在適當?shù)奈恢蒙?。但是C語言的一個特點就是太靈活，太強大，它允許你干預“內(nèi)存對齊”。如果你想了解更加底層的秘密，“內(nèi)存對齊”對你就不應(yīng)該再模糊了。這也是一個大小端模式的問題
每個特定平臺上的編譯器都有自己的默認“對齊系數(shù)”(也叫對齊模數(shù))。程序員可以通過預編譯命令#pragma pack(n)來改變這一系數(shù)，其中的n就是你要指定的“對齊系數(shù)”。
規(guī)則：
1、數(shù)據(jù)成員對齊規(guī)則：結(jié)構(gòu)(struct)(或聯(lián)合(union))的數(shù)據(jù)成員，第一個數(shù)據(jù)成員放在offset為0的地方，以后每個數(shù)據(jù)成員的對齊「按照#pragma pack指定的數(shù)值和這個數(shù)據(jù)成員自身長度中，比較小的那個進行」。
2、結(jié)構(gòu)(或聯(lián)合)的整體對齊規(guī)則：在數(shù)據(jù)成員完成各自對齊之后，結(jié)構(gòu)(或聯(lián)合)本身也要進行對齊，對齊將「按照#pragma pack 指定的數(shù)值和結(jié)構(gòu)(或聯(lián)合) 最大數(shù)據(jù)成員長度中，比較小的那個進行」對齊。
3、結(jié)合1、2可推斷：當#pragma pack的n值等于或超過所有數(shù)據(jù)成員長度的時候，這個n值的大小將不產(chǎn)生任何效果。
#pragma pack(n) ?設(shè)定變量以n字節(jié)為對齊方式：
「作用」：指定結(jié)構(gòu)體、聯(lián)合以及類成員
「語法」：#pragma pack( [show] | [push | pop] [, identifier], n )
1，pack提供數(shù)據(jù)聲明級別的控制，對定義不起作用；
2，調(diào)用pack時不指定參數(shù)，n將被設(shè)成默認值；
n：可選參數(shù)；指定packing的數(shù)值，以字節(jié)為單位；缺省數(shù)值是8，合法的數(shù)值分別是1、2、4、8、16。其他參數(shù)都是可選的可先不了解
#include
#pragma?pack(2)//?值只能填1?2?4?8?16??這里最好是看結(jié)構(gòu)里邊最小的成員?這里是char?所以最好是填1??//但是當#pragma?pack指定的值等于或者超過所有數(shù)據(jù)成員長度的時候，這個指定值的大小將不產(chǎn)生任何效果
typedef?struct?_A?{
?double?x;//4
?int?y;//4
?char?p;//1
?
}NODE;
//8+4+1+1=14按n為2
//8+4+1+3=16按n為4以上或者使用系統(tǒng)自動對齊
#pragma?pack(8)//設(shè)定為4字節(jié)對齊
typedef?struct?test
{
?char?m1;
?double?m4;
?int?m3;
}NODE2;
//1+1+4+8=14//按n為2
//1+7+8+4=20?不滿足8的倍數(shù)??加4等于24滿足??總：1+7+8+4+4=24
int?main(void)?{
?printf("%d\n",?sizeof(NODE));
?printf("%d",?sizeof(NODE2));
}
結(jié)構(gòu)、聯(lián)合或者類的數(shù)據(jù)成員，第一個放在偏移為0的地方；以后每個數(shù)據(jù)成員的對齊，
按照#pragma?pack指定的數(shù)值和這個數(shù)據(jù)成員自身長度兩個中比較小的那個進行；
也就是說，當#pragma?pack指定的值等于或者超過所有數(shù)據(jù)成員長度的時候，
這個指定值的大小將不產(chǎn)生任何效果
每個成員分別對齊，即每個成員按自己的方式對齊，并最小化長度；規(guī)則就是每個成員按其類型的對齊參數(shù)（通常是這個類型的大?。┖椭付▽R參數(shù)中較小的一個對齊。
大小端：
如：int?11?22?33?44
在存儲的時候
大端：11?22?33?44
??0??1???2??3
??低地址---->?高地址
小端：44?33?22?11
??0??1???2??3
??低地址---->?高地址
大小端的差異在于存放順序不同
常見的操作系統(tǒng)是小端，通訊協(xié)議是大端。復制代碼
//結(jié)構(gòu)體例子：使用尾插法創(chuàng)建鏈表
#include//單鏈表的創(chuàng)建
typedef?struct?_node?{
?int?nb;//數(shù)值
?struct?_node?*nxte;//定義一個指向下一個的節(jié)點的指針
}NODE;
typedef?struct?_link{//利用這個結(jié)構(gòu)體?封裝?首尾節(jié)點
?NODE?*head;
?NODE?*qt;
}link;
void??add(link?*phead,?link?*qt,?int?n);//定義函數(shù)將?首尾指針傳入
int?main(void)?{
?link?head,?q;//定義一個結(jié)構(gòu)，連指針都不是的
?head.head?=?q.qt?=?NULL;//初始化
?int?n;
?for?(scanf("%d",?&n);?n?!=?-1;?scanf("%d",?&n))?{
??add(&head,?&q,?n);//將地址?值傳入
?}
?NODE?*t;
?t?=?head.head;//利用臨時結(jié)構(gòu)將鏈表輸出
?for?(;?t;?t?=?t->nxte)?{
??printf("%d?",?t->nb);
?}
?return?0;
}
//尾插法
void??add(link?*phead,?link?*qt,?int?n)?{
?NODE?*p?=?(NODE*)malloc(sizeof(NODE));//為新結(jié)點開辟空間
?p->nb?=?n;
?p->nxte?=?NULL;
?if?(phead->head?==?NULL)?{//判斷首結(jié)點是否為空
??phead->head?=?p;//是空的就讓首結(jié)點等于新結(jié)點
?}
?else?{//不為空時，讓尾結(jié)點依次跑到后面去
??qt->qt->nxte?=?p;
?}
?qt->qt?=?p;
}
4、union 共用體（聯(lián)合體）
在進行某些算法的C語言編程的時候，需要使幾種不同類型的變量存放到同一段內(nèi)存單元中。也就是使用覆蓋技術(shù)，幾個變量互相覆蓋。這種幾個不同的變量共同占用一段內(nèi)存的結(jié)構(gòu)，在C語言中 以關(guān)鍵字union聲明的一種數(shù)據(jù)結(jié)構(gòu)，這種被稱作“共用體”類型結(jié)構(gòu)，也叫聯(lián)合體。
“聯(lián)合”與“結(jié)構(gòu)”有一些相似之處。但兩者有本質(zhì)上的不同。在結(jié)構(gòu)中各成員有各自的內(nèi)存空間，一個結(jié)構(gòu)體變量的總長度大于等于各成員長度之和。而在“聯(lián)合”中，各成員共享一段內(nèi)存空間，一個聯(lián)合變量的長度等于各成員中最長的長度。注意這里所謂的共享不是指把多個成員同時裝入一個聯(lián)合變量內(nèi)，而是指該聯(lián)合變量可被賦予任一成員值，但每次只能賦一種值，賦入新值則沖去舊值，共用體變量中起作用的成員是最后一次存放的成員，在存入一個新成員后，原有成員就失去作用，共用體變量的地址和它的各成員的地址都是同一地址
一個聯(lián)合類型必須經(jīng)過定義之后，才能把變量說明為該聯(lián)合類型:
聯(lián)合的定義:
定義一個聯(lián)合類型的一般形式為：
union?[name](聯(lián)合名)???name是可選的
{
成員表
};
成員表中含有若干成員，成員的一般形式為：?類型說明符?成員名
成員名的命名應(yīng)符合標識符的規(guī)定。
union?Data
{
???int?i;
???double?f;
???char??str[20];
}?data;
現(xiàn)在?Data所有的成員共享一個空間，同一時間只有一個成員是的值有效的，Data?類型的變量可以存儲一個整數(shù)、
一個浮點數(shù)，或者一個字符串。這意味著一個變量（相同的內(nèi)存位置）可以存儲多個多種類型的數(shù)據(jù)。
您可以根據(jù)需要在一個共用體內(nèi)使用任何內(nèi)置的或者用戶自定義的數(shù)據(jù)類型。
共用體占用的內(nèi)存應(yīng)足夠存儲共用體中最大的成員。例如，在上面的實例中，
Data?將占用?20?個字節(jié)的內(nèi)存空間，因為在各個成員中，字符串所占用的空間是最大的。復制代碼
注意：1、不能把共用體變量作為函數(shù)參數(shù)，也不能是函數(shù)帶回共用體變量，但可以使專用指向共用體變量的指針
2、所有成員占用同一段內(nèi)存，修改一制個成員會影響其余所有成員。
共用體的訪問：共用體訪問成員的值時一般使用.運算符，指針時用->運算符（和結(jié)構(gòu)體是一樣的）
typedef?union?_node?{
?int?a;
?double?b;
?char?c;
?union?_node?*p;
}NODE;
int?main(void)?{
?NODE?a;//定義變量
?NODE?t;
?a.b;//用.訪問
?t.p->a;//指針用->訪問
}
聯(lián)合的使用規(guī)則幾乎和結(jié)構(gòu)體strtct的規(guī)則用法一樣，只不過是內(nèi)部表示的不同。
補充：
還有一個是無名聯(lián)合體，它是和無名結(jié)構(gòu)體的工作原理是相同的復制代碼
#include//簡單的例子
#include
typedef?union?_node{
?int?a;
?double?b;
?char?c[20];
}NODE;
int?main(void)?{
?NODE?a;//這里只定義一個變量
?a.a?=?666;
?printf("%d\n",?a.a);
?a.b?=?9.99;
?printf("%f\n",?a.b);
?strcpy(a.c,?"hello?world!");
?printf("%s\n",?a.c);
?//我們看到，三個都被完整的輸出了，因為在同一時刻，只有一個成員是有效的
}
輸出：
666
9.990000
hellow?world!
共用體的作用：
1、節(jié)省內(nèi)存，有兩個很長的數(shù)據(jù)結(jié)構(gòu)，不會同時使用，比如一個表示老師，一個表示學生，如果要統(tǒng)計教師和學生的情況用結(jié)構(gòu)體的話就有點浪費了！用結(jié)構(gòu)體的話，只占用最長的那個數(shù)據(jù)結(jié)構(gòu)所占用的空間，就足夠了！
2、實現(xiàn)不同類型數(shù)據(jù)之間的類型轉(zhuǎn)換，遇到各種類型的數(shù)據(jù)共用存儲空間，很方便的實現(xiàn)了不同數(shù)據(jù)類型之間的轉(zhuǎn)換，不需要顯示的強制類型轉(zhuǎn)換。
其他：1、確定CPU的模式：大端、小端模式確定
大小端不同，則存儲的方式也存在差別，比如int需要4個字節(jié)，而char只需要1個字節(jié)，根據(jù)1個字節(jié)所在的具體位置即可判定CPU的模式
2、寄存器的定義，實現(xiàn)整體的訪問和單項的訪問
//共用體綜合例子：根據(jù)輸入的數(shù)據(jù)類型輸出需要的相應(yīng)的數(shù)據(jù)
#include
#include//數(shù)據(jù)類型輸出???5*4??m?n?????n的第幾個x?
union?node?{
?int?a;
?double?b;
?char?c[30];
}add[10000];
char?p[10000][30];?//保存的字符串數(shù)組
int?main(void)?{
?int?n,?m;
?scanf("%d?%d",?&n,?&m);
?int?x;
?double?y;
?char?t[50];
?int?i,?j;
?for?(i?=?0;?i?//輸入
??scanf("%s",?&p[i]);//作為字符串數(shù)組，需要取地址
??if?(strcmp("INT",?p[i])?==?0)?{//整形
???scanf("%d",?&x);
???add[i].a?=?x;
??}
??else?if(strcmp("DOUBLE",p[i])==0){//浮點
???scanf("%lf",?&y);
???add[i].b?=?y;
??}
??else?if?(strcmp("STRCING",?p[i])?==?0)?{//字符串
???scanf("%s",?t);
???strcpy(add[i].c,?t);
??}
?}
?for?(i?=?0;?i?//輸出
??scanf("%d",?&j);
??if?(strcmp("INT",?p[j])?==?0)?{
???printf("%d\n",?add[j].a);
??}
??else?if?(strcmp("DOUBLE",?p[j])?==?0)
??{
???printf("%f\n",?add[j].b);
??}else?if(strcmp("STRING",p[j])==0)
??{
???printf("%s\n",?add[j].c);
??}
?}
?return?0;
}
//輸入：
/*
5?4
INT?456
DOUBLE?123.56
DOUBLE?0.476
STRING?welcomeToC
STRING?LemonTree
0
1
2
4
*/
//輸出：
/*
456
123.56
0.48
LemonTree
*/
來源：稀土掘金 作者：Mr_Li_鏈接：https://juejin.cn/post/6844904177517199373
版權(quán)申明：內(nèi)容來源網(wǎng)絡(luò)，版權(quán)歸原創(chuàng)者所有。除非無法確認，都會標明作者及出處，如有侵權(quán)，煩請告知，我們會立即刪除并致歉!
???????????????? ?END ?????????????????