聯合體
用途：使幾個不同型別的變數共佔一段記憶體(相互覆蓋)

結構體是一種構造資料型別
用途：把不同型別的資料組合成一個整體-------自定義資料型別

 

總結：

宣告一個聯合體：

[cpp] view plaincopy

1. union abc{  
2.           int i;  
3.           char m;  
4.          };  

1. 在聯合體abc中，整型量i和字元m公用同一記憶體位置。

2. 當一個聯合被說明時，編譯程式自動地產生一個變數，其長度為聯合中最大的變數長度。
 

========================================================================================================

結構體變數所佔記憶體長度是各成員佔的記憶體長度的總和。

共同體變數所佔記憶體長度是各最長的成員佔的記憶體長度。

共同體每次只能存放哪個的一種！！

共同體變數中起作用的成員是最後一次存放的成員，在存入新的成員後原有的成員失去了作用！

=====================================================================================

Struct與Union主要有以下區別:

1. struct和union都是由多個不同的資料型別成員組成, 但在任何同一時刻, union中只存放了一個被選中的成員, 而struct的所有成員都存在。在struct中，各成員都佔有自己的記憶體空間，它們是同時存在的。一個struct變數的總長度等於所有成員長度之和。在Union中，所有成員不能同時佔用它的記憶體空間，它們不能同時存在。Union變數的長度等於最長的成員的長度。

2. 對於union的不同成員賦值, 將會對其它成員重寫, 原來成員的值就不存在了, 而對於struct的不同成員賦值是互不影響的。

在C/C++程式的編寫中，當多個基本資料型別或複合資料結構要佔用同一片記憶體時，我們要使用聯合體；當多種型別，多個物件，多個事物只取其一時（我們姑且通俗地稱其為“n 選1”），我們也可以使用聯合體來發揮其長處。

首先看一段程式碼：

[html] view plaincopy

1. union myun  
2. {  
3.      struct { int x; int y; int z; }u;  
4.      int k;  
5. }a;  
6. int main()  
7. {  
8.      a.u.x =4;  
9.      a.u.y =5;  
10.      a.u.z =6;  
11.      a.k = 0;  
12.      printf("%d %d %d\n",a.u.x,a.u.y,a.u.z);  
13.      return 0;  
14. }  

union型別是共享記憶體的，以size最大的結構作為自己的大小，這樣的話，myun這個結構就包含u這個結構體，而大小也等於u這個結構體的大小，在記憶體中的排列為宣告的順序x,y,z從低到高，然後賦值的時候，在記憶體中，就是x的位置放置4，y的位置放置5，z的位置放置6，現在對k賦值，對k的賦值因為是union，要共享記憶體，所以從union的首地址開始放置，首地址開始的位置其實是x的位置，這樣原來記憶體中x的位置就被k所賦的值代替了，就變為0了，這個時候要進行列印，就直接看記憶體裡就行了，x的位置也就是k的位置是0，而 y，z的位置的值沒有改變，所以應該是0,5,6

==========================================================================================================================================================

1. struct的巨大作用

面對一個大型C/C++程式時，只看其對struct的使用情況我們就可以對其編寫者的程式設計經驗進行評估。因為一個大型的C/C++程式，勢必要涉及一些(甚至大量)進行資料組合的結構體，這些結構體可以將原本意義屬於一個整體的資料組合在一起。從某種程度上來說，會不會用struct，怎樣用struct是區別一個開發人員是否具備豐富開發經歷的標誌。在網路協議、通訊控制、嵌入式系統的C/C++程式設計中，我們經常要傳送的不是簡單的位元組流（char型陣列），而是多種資料組合起來的一個整體，其表現形式是一個結構體。經驗不足的開發人員往往將所有需要傳送的內容依順序儲存在char型陣列中，通過指標偏移的方法傳送網路報文等資訊。這樣做程式設計複雜，易出錯，而且一旦控制方式及通訊協議有所變化，程式就要進行非常細緻的修改。一個有經驗的開發者則靈活運用結構體，舉一個例子，假設網路或控制協議中需要傳送三種報文，其格式分別為packetA、packetB、packetC：

 

[cpp] view plaincopy

1. struct structA   
2. {  
3.     int a;  
4.     char b;  
5. };  
6. struct structB   
7. {  
8.     char a;  
9.     short b;  
10. };  
11. struct structC  
12. {  
13.     int a;  
14.     char b;  
15.     float c;  
16. }  

優秀的程式設計者這樣設計傳送的報文：

[cpp] view plaincopy

1. struct CommuPacket  
2. {  
3.     int iPacketType;　　//報文型別標誌  
4.     union　　　　　　   //每次傳送的是三種報文中的一種，使用union  
5.     {  
6.         struct structA packetA;  
7.         struct structB packetB;  
8.         struct structC packetC;  
9.     }  
10. };  

在進行報文傳送時，直接傳送struct CommuPacket一個整體。

　　假設傳送函式的原形如下：

// pSendData：傳送位元組流的首地址，iLen：要傳送的長度
Send(char * pSendData, unsigned int iLen);
傳送方可以直接進行如下呼叫傳送struct CommuPacket的一個例項sendCommuPacket：
Send( (char *)&sendCommuPacket , sizeof(CommuPacket) );
假設接收函式的原形如下：
// pRecvData：傳送位元組流的首地址，iLen：要接收的長度
//返回值：實際接收到的位元組數
unsigned int Recv(char * pRecvData, unsigned int iLen)；
接收方可以直接進行如下呼叫將接收到的資料儲存在struct CommuPacket的一個例項
recvCommuPacket中：

Recv( (char *)&recvCommuPacket , sizeof(CommuPacket) );
接著判斷報文型別進行相應處理：

[cpp] view plaincopy

1. switch(recvCommuPacket. iPacketType)  
2. {  
3.     case PACKET_A:  
4.     …    //A類報文處理  
5.     break;  
6.     case PACKET_B:  
7.     …　 //B類報文處理  
8.     break;  
9.     case PACKET_C:  
10.     …   //C類報文處理  
11.     break;  
12. }  

 

以上程式中最值得注意的是

Send( (char *)&sendCommuPacket , sizeof(CommuPacket) );
Recv( (char *)&recvCommuPacket , sizeof(CommuPacket) );
中的強制型別轉換：(char *)&sendCommuPacket、(char *)&recvCommuPacket，先取地址，再轉化為char型指標，這樣就可以直接利用處理位元組流的函式。

　　利用這種強制型別轉化，我們還可以方便程式的編寫，例如要對sendCommuPacket所處記憶體初始化為0，可以這樣呼叫標準庫函式memset()：

memset((char *)&sendCommuPacket,0, sizeof(CommuPacket));

 

====================================================================================================================

 

2. struct成員對齊

Intel、微軟等公司曾經出過一道類似的面試題：

[cpp] view plaincopy

1. #include <iostream.h>  
2. #pragma pack(8)  
3. struct example1  
4. {  
5.     short a;  
6.     long b;  
7. };  
8. struct example2  
9. {  
10.     char c;  
11.     example1 struct1;  
12.     short e;      
13. };  
14. #pragma pack()  
15. int main(int argc, char* argv[])  
16. {  
17.     example2 struct2;  
18.     cout << sizeof(example1) << endl;  
19.     cout << sizeof(example2) << endl;  
20.     cout << (unsigned int)(&struct2.struct1) - (unsigned int)(&struct2) << endl;  
21.     return 0;  
22. }  

問程式的輸出結果是什麼？

答案是：

8
16
4

不明白？還是不明白？下面一一道來：

2.1 自然對界

    struct是一種複合資料型別，其構成元素既可以是基本資料型別（如int、long、float等）的變數，也可以是一些複合資料型別（如 array、struct、union等）的資料單元。對於結構體，編譯器會自動進行成員變數的對齊，以提高運算效率。預設情況下，編譯器為結構體的每個 成員按其自然對界（natural alignment）條件分配空間。各個成員按照它們被宣告的順序在記憶體中順序儲存，第一個成員的地址和整個結構的地址相同。

    自然對界(natural alignment)即預設對齊方式，是指按結構體的成員中size最大的成員對齊。

    例如：

[cpp] view plaincopy

1. struct naturalalign  
2. {  
3.     char a;  
4.     short b;  
5.     char c;  
6. };  

在上述結構體中，size最大的是short，其長度為2位元組，因而結構體中的char成員a、c都以2為單位對齊，sizeof(naturalalign)的結果等於6；

如果改為：

[cpp] view plaincopy

1. struct naturalalign  
2. {  
3.     char a;  
4.     int b;  
5.     char c;  
6. };  

其結果顯然為12。

2.2 指定對界

一般地，可以通過下面的方法來改變預設的對界條件：

 

    使用偽指令#pragma pack (n)，編譯器將按照n個位元組對齊；
    使用偽指令#pragma pack ()，取消自定義位元組對齊方式。

　　注意：如果#pragma pack (n)中指定的n大於結構體中最大成員的size，則其不起作用，結構體仍然按照size最大的成員進行對界。

例如：

[cpp] view plaincopy

1. #pragma pack (n)  
2. struct naturalalign  
3. {  
4.     char a;  
5.     int b;  
6.     char c;  
7. };  

當n為4、8、16時，其對齊方式均一樣，sizeof(naturalalign)的結果都等於12。而當n為2時，其發揮了作用，使得sizeof(naturalalign)的結果為8。

2.3 面試題的解答

　　至此，我們可以對Intel、微軟的面試題進行全面的解答。

　　程式中第2行#pragma pack (8)雖然指定了對界為8，但是由於struct example1中的成員最大size為4（long變數size為4），故struct example1仍然按4位元組對界，struct example1的size為8，即第18行的輸出結果；

　　struct example2中包含了struct example1，其本身包含的簡單資料成員的最大size為2（short變數e），但是因為其包含了struct example1，而struct example1中的最大成員size為4，struct example2也應以4對界，#pragma pack (8)中指定的對界對struct example2也不起作用，故19行的輸出結果為16；

　　由於struct example2中的成員以4為單位對界，故其char變數c後應補充3個空，其後才是成員struct1的記憶體空間，20行的輸出結果為4。

 

3. C和C++之間結構體的深層區別

      在C++語言中struct具有了“類”　的功能，其與關鍵字class的區別在於struct中成員變數和函式的預設訪問許可權為public，而class的為private。

例如，定義struct類和class類：

[cpp] view plaincopy

1. struct structA  
2. {  
3.       char a;  
4.       …  
5. }  
6. class classB  
7. {  
8.       char a;  
9.       …  
10. }  

則：

[cpp] view plaincopy

1. struct A a;  
2. a.a = 'a';    //訪問public成員，合法  
3. classB b;  
4. b.a = 'a';    //訪問private成員，不合法  

 

許多文獻寫到這裡就認為已經給出了C++中struct和class的全部區別，實則不然，另外一點需要注意的是：

　　C++中的struct保持了對C中struct的全面相容（這符合C++的初衷——“a better c”），因而，下面的操作是合法的：

[cpp] view plaincopy

1. //定義struct  
2. struct structA  
3. {  
4.     char a;  
5.     char b;  
6.     int c;  
7. };  
8. structA a = {'a' , 'a' ,1};    // 定義時直接賦初值  

即struct可以在定義的時候直接以{ }對其成員變數賦初值，而class則不能。

 

4. struct程式設計注意事項

看看下面的程式：

 

[cpp] view plaincopy

1. #include <iostream.h>  
2. struct structA  
3. {  
4.     int iMember;  
5.     char *cMember;  
6. };  
7. int main(int argc, char* argv[])  
8. {  
9.     structA instant1,instant2;  
10.     char c = 'a';      
11.     instant1.iMember = 1;  
12.     instant1.cMember = &c;  
13.     instant2 = instant1;  
14.     cout << *(instant1.cMember) << endl;  
15.     *(instant2.cMember) = 'b';  
16.     cout << *(instant1.cMember) << endl;  
17.     return 0;  
18. }  

14行的輸出結果是：a
16行的輸出結果是：b

　　Why?我們在15行對instant2的修改改變了instant1中成員的值！

　　原因在於13行的instant2 = instant1賦值語句採用的是變數逐個拷貝，這使得instant1和instant2中的cMember指向了同一片記憶體，因而對instant2的修改也是對instant1的修改。

　　在C語言中，當結構體中存在指標型成員時，一定要注意在採用賦值語句時是否將2個例項中的指標型成員指向了同一片記憶體。

　　在C++語言中，當結構體中存在指標型成員時，我們需要重寫struct的拷貝建構函式並進行“=”操作符過載。

 

===================================================================================================================

C語言中的結構體(struct)和聯合體(union)的簡介

看到有朋友介紹union，我以前還沒有用過這個東西呢，也不懂，就去搜了點資料來看，也轉給大家，希望罈子裡的給予改正或補充。謝謝！

聯 合(union) 
1. 聯合說明和聯合變數定義 
聯合也是一種新的資料型別, 它是一種特殊形式的變數。 
聯合說明和聯合變數定義與結構十分相似。其形式為: 
union 聯合名{ 
資料型別 成員名; 
資料型別 成員名; 
... 
} 聯合變數名; 
聯合表示幾個變數公用一個記憶體位置, 在不同的時間儲存不同的資料型別 和不同長度的變數。 
下例表示說明一個聯合a_bc: 

[cpp] view plaincopy

1. union a_bc{   
2.     int i;   
3.     char mm;   
4. };   

再用已說明的聯合可定義聯合變數。 
例如用上面說明的聯合定義一個名為lgc的聯合變數, 可寫成: 
union a_bc lgc; 
在聯合變數lgc中, 整型量i和字元mm公用同一記憶體位置。 
當一個聯合被說明時, 編譯程式自動地產生一個變數, 其長度為聯合中最大的變數長度。 
聯合訪問其成員的方法與結構相同。同樣聯合變數也可以定義成陣列或指標,但定義為指標時, 也要用"->;"符號,此時聯合訪問成員可表示成: 
聯合名->;成員名 
另外, 聯合既可以出現在結構內, 它的成員也可以是結構。

例如：

[cpp] view plaincopy

1. struct{   
2.     int age;   
3.     char *addr;   
4.     union{   
5.         int i;   
6.         char *ch;   
7.     }x;   
8. }y[10];   

 

若要訪問結構變數y[1]中聯合x的成員i, 可以寫成: 
y[1].x.i; 
若要訪問結構變數y[2]中聯合x的字串指標ch的第一個字元可寫成: 
*y[2].x.ch; 
若寫成"y[2].x.*ch;"是錯誤的。

2. 結構和聯合的區別 
結構和聯合有下列區別: 
1. 結構和聯合都是由多個不同的資料型別成員組成, 但在任何同一時刻, 聯合轉只存放了一個被選中的成員, 而結構的所有成員都存在。 
2. 對於聯合的不同成員賦值, 將會對其它成員重寫, 原來成員的值就不存在了, 而對於結構的不同成員賦值是互不影響的。 
下面舉一個例了來加深對聯合的理解。 

例4：

[cpp] view plaincopy

1. main()   
2. {   
3.     union{    
4.     int i;   
5.     struct{    
6.         char first;   
7.         char second;   
8.     }half;   
9. }number;   
10.   
11. number.i=0x4241;    
12. printf("%c%cn", number.half.first, number.half.second);   
13. number.half.first='a';    
14. number.half.second='b';   
15. printf("%xn", number.i);   
16. getch();   
17. }   

輸出結果為：

AB

6261

從上例結果可以看出: 當給i賦值後, 其低八位也就是first和second的值;當給first和second賦字元後, 這兩個字元的ASCII碼也將作為i的低八~~~~這裡沒看太懂？？？

 

共用體

構造資料型別,也叫聯合體

用途：使幾個不同型別的變數共佔一段記憶體(相互覆蓋)

 

結構體是一種構造資料型別

用途：把不同型別的資料組合成一個整體-------自定義資料型別