一共用體的概念

當需要把不同型別的變數存放到同一段記憶體單元或對同一段記憶體單元的資料按不同型別處理則

需要使用共用體資料結構

例把一個整型變數一個字元型變數一個實型變數放在同一個地址開始的記憶體單元中

共用體的定義形式

union 共用體名

成員列表

變數列表

注意區分

共用體各成員佔相同的起始地址所佔記憶體長度等於最長的成員所佔記憶體

結構體各成員佔不同的地址所佔記憶體長度等於全部成員所佔記憶體之和

二共用體變數的引用

只能引用共用體變數的成員如

 union data a;

 a.i;

 a.ch;

 a.f;

三共用體型別資料的特點

共用體變數中的值是最後一次存放的成員的值如

a.i = 1;

a.ch = 'a';

a.f = 1.5;

完成以上三個賦值語句後共用體邊量的值是 1.5而 a.i=1 和 a.ch='a'已無意義

共用體變數不能初始化例

union data

{

int i;

char ch;

float f;

}a={1,'a', 1.5}  錯誤！！！

共用體常用來節省記憶體，特別是一些嵌入式程式設計，記憶體是非常寶貴的！

共用體也常用於作業系統資料結構或硬體資料結構！

union在作業系統底層的程式碼中用的比較多，因為它在記憶體共賞佈局上方便且直觀。所以網路程式設計，協議分析，核心程式碼上有一些用到union都比較好懂，簡化了設計。

妙用例項

1. 為了方便看懂程式碼。

比如說想寫一個3 * 3的矩陣，可以這樣寫：
[注：下面用紅色部分標記的地方是後來新增上去的，謝謝yrqing718的提醒！]

1. struct  Matrix
2. {
3.     union
4.     {
5.         struct
6.         {
7.             float  _f11, _f12, _f13, _f21, _f22, _f23, _f31, _f32, _f33;
8.         };
9.         float  f[3][3];
10.     }_matrix;
11. };
12. struct  Matrix m;

這兩個東西共同使用相同的空間，所以沒有空間浪費，在需要整體用矩陣的時候可以用
m._matrix.f

1. #define TRUE 1
2. #define FALSE 0
3. #define BOOL int
4. BOOL  isBigEndian()
5. {
6. int  i = 1;   /* i = 0x00000001*/
7.     char  c = *(char  *)&i; /* 注意不能寫成 char c = (char)i; */
8. return  (int )c != i;
9. }

如果是little endian位元組序的話，那個i = 1；的記憶體從小到大依次放的是：0x01 0x00 0x00 0x00，如是，按照i的起始地址變成按照char *方式（1位元組）存取，即得c = 0x01；反之亦然也許看起來不是很清晰，下面來看一下這個：

1. BOOL  isBigEndian()
2. {
3.     union
4.     {
5.         int  i;
6.         char  c;
7.     }test;
8.     test.c = 2;
9.     return  test.i != 2;
10. }

這裡用的是union來控制這個共享佈局，有個知識點就是union裡面的成員c和i都是從低地址開始對齊的。同樣可以得到如此結果，而且不用轉換，清晰一些。什麼，不覺得清晰？？那再看下面的例子：（2）.將little endian下的long long型別的值換成 big endian型別的值。已經知道系統提供了下面的api：long htonl(long lg);作用是把所有的位元組序換成大端位元組序。因此得出下面做法：

1. long  long  htonLL(long  long  lg)
2. {
3.     union  
4.     {
5.         struct  
6.         { 
7.             long  low;
8.             long  high;
9.         }val_1;
10.         long  long  val_2;
11.     }val_arg, val_ret;
12.     if ( isBigEndian() )
13.         return  lg;
14.     val_arg.val_2 = lg;
15.     val_ret.val_1.low = htonl( val_arg.val_1.high );
16.     val_ret.val_1.high = htonl( val_arg.val_1.low );    
17.     return  val_ret.val_2;
18. }

只要把記憶體結構的草圖畫出來就比較容易明白了。

(3).為了理解c++類的佈局，再看下面一個例子。有如下類：

1. class  Test
2. {
3. public :
4.     float  getFVal(){ return  f;}
5. private :
6.     int  i;
7.     char  c;
8.     float  f;
9. };
10. Test t;

不能在類Test中增加程式碼，給物件中的f賦值7.0f.

1. class  Test_Cpy
2. {
3.  public :
4.     float  getVal(){ return  f;}
5.     float  setVal(float  f){ this ->f = f;}
6. private :
7.     int  i;
8.     char  c;
9.     float  f;
10. };
11. ....
12. int  main()
13. {
14.     Test t;
15.     union
16.     {
17.          Test t1, 
18.          Test_Cpy t2;
19.     }test;
20.     test.t2.setVal(7.0f);
21.     t = test.t1;
22.     assert( t.getVal() == 7.0f );   
23.     return  0;
24. }

說明：因為在增加類的成員函式時候，那個類的物件的佈局基本不變。因此可以寫一個與Test類一樣結構的類Test_Cpy，而多了一個成員函式setVal，再用uinon結構對齊，就可以給私有變數賦值了。（這種方法在有虛機類和虛擬函式機制時可能失靈，故不可移植）至於詳細的討論，網上有，這個例子在實際中沒有用途，只是用來考察這個記憶體佈局的使用而已.

 4 

1. 在嵌入式系統開發中，有時需要將一些變數儲存在EEPROM中，變數型別若是char、int就很好辦，可是如果要儲存float、double型別的變數怎麼辦呢？

   這個問題可以用共用體解決：

   union myfloat

   {

       char i[4];

       float j;

   }Test;

   因為float是四個位元組，因此我們定義一個4個元素的char陣列和float公用一段記憶體，接下來就是EEPROM存取了

2. 2

   在程式中要使用 j 的地方使用Test.j就行了，

   想把 j 存入EEPROM可以這樣：

   EEPROM_WRITE(0,myfloat.i[0]);

   EEPROM_WRITE(1,myfloat.i[1]);

   EEPROM_WRITE(2,myfloat.i[2]);

   EEPROM_WRITE(3,myfloat.i[3]);

   注：上面引數0、1、2、3為EEPROM地址，上面的EEPROM_WRITE只是示意，有時需要對地址使用（void*）進行型別轉換

3. 3

   想把 j 從EEPROM讀出可以這樣：

   myfloat.i[0]=EEPROM_READ(0);

   myfloat.i[1]=EEPROM_READ(1);

   myfloat.i[2]=EEPROM_READ(2);

   myfloat.i[3]=EEPROM_READ(3);

   然後在程式中繼續使用Test.j就可以了

   是不是很簡單呢