C++联合体union用法实例详解

这篇文章主要介绍了C++联合体union用法,较为详细的分析了C++中联合体的概念、实用技巧及相关注意事项,需要的朋友可以参考下

本文实例讲述了C++联合体union用法。分享给大家供大家参考。具体如下：

我们应该按照C中的convention去使用union，这是我这篇文章要给出的观点。虽然C++使得我们可以扩展一些新的东西进去，但是，我建议你不要那样去做，看完这篇文章之后，我想你大概也是这么想的。

C由于没有类的概念，所有类型其实都可以看作是基本类型的组合，因此在union中包含struct也就是一件很自然的事情了，到了C++之后，既然普遍认为C++中的struct与class基本等价，那么union中是否可以有类成员呢?先来看看如下的代码:

1. struct TestUnion 
2. { 
3. 　　 TestUnion() {} 
4. }; 
5.  
6. typedef union 
7. { 
8. 　　 TestUnion obj; 
9. } UT; 
10.  
11. int main (void) 
12. { 
13. 　　 return 0; 
14. } 

编译该程序，我们将被告知:

error C2620: union '__unnamed' : member 'obj' has user-defined constructor or non-trivial default constructor

而如果去掉那个什么也没干的构造函数，则一切OK。

为什么编译器不允许我们的union成员有构造函数呢?我无法找到关于这个问题的比较权威的解释，对这个问题，我的解释是:

如果C++标准允许我们的union有构造函数，那么，在进行空间分配的时候要不要执行这个构造函数呢?如果答案是yes，那么如果TestUnion 的构造函数中包含了一些内存分配操作，或者其它对整个application状态的修改，那么，如果我今后要用到obj的话，事情可能还比较合理，但是如果我根本就不使用obj这个成员呢?由于obj的引入造成的对系统状态的修改显然是不合理的;反之，如果答案是no，那么一旦我们今后选中了obj来进行 操作，则所有信息都没有初始化(如果是普通的struct，没什么问题，但是，如果有虚函数呢?)。更进一步，假设现在我们的union不是只有一个 TestUnion obj，还有一个TestUnion2 obj2，二者均有构造函数，并且都在构造函数中执行了一些内存分配的工作(甚至干了很多其它事情)，那么，如果先构造obj，后构造obj2，则执行的 结果几乎可以肯定会造成内存的泄漏。

鉴于以上诸多麻烦(可能还有更多麻烦)，在构造union时，编译器只负责分配空间，而不负责去执行附加的初始化工作，为了简化工作，只要我们提供了构造函数，就会收到上面的error。

同理，除了不能加构造函数，析构函数/拷贝构造函数/赋值运算符也是不可以加。

此外，如果我们的类中包含了任何virtual函数，编译时，我们将收到如下的错误信息:

error C2621: union '__unnamed' : member 'obj' has copy constructor

所以，打消在union中包含有构造函数/析构函数/拷贝构造函数/赋值运算符/虚函数的类成员变量的念头，老老实实用你的C风格struct吧!

不过，定义普通的成员函数是OK的，因为这不会使得class与C风格的struct有任何本质区别，你完全可以将这样的class理解为一个C风格的struct + n个全局函数。

现在，再看看在类中包含内部union时会有什么不同。看看下面的程序，并请注意阅读程序提示:

1. class TestUnion 
2. { 
3. 　　 union DataUnion 
4. 　　 { 
5. 　　 DataUnion(const char*); 
6. 　　 DataUnion(long); 
7. 　　 const char* ch_; 
8. 　　 long l_; 
9. 　　 } data_; 
10.  
11. 　　public: 
12. 　　 TestUnion(const char* ch); 
13. 　　 TestUnion(long l); 
14. }; 
15.  
16. TestUnion::TestUnion(const char* ch) : data_(ch) // if you want to use initialzing list to initiate a nested-union member， the union must not be anonymous and must have a constructor。 
17. {} 
18.  
19. TestUnion::TestUnion(long l) : data_(l) 
20. {} 
21.  
22. TestUnion::DataUnion::DataUnion(const char* ch) : ch_(ch) 
23. {} 
24.  
25. TestUnion::DataUnion::DataUnion(long l) : l_(l) 
26. {} 
27.  
28. int main (void) 
29. { 
30. 　　 return 0; 
31. } 

正如上面程序所示，C++中的union也可以包含构造函数，但是，这虽然被语言所支持，但实在是一种不佳的编程习惯，因此， 我不打算对上面的程序进行过多的说明。我更推荐如下的编程风格:

1. class TestUnion 
2. { 
3. 　　 union DataUnion 
4. 　　 { 
5. 　　 const char* ch_; 
6. 　　 long l_; 
7. 　　 } data_; 
8. 　　 
9. 　　public: 
10. 　　 TestUnion(const char* ch); 
11. 　　 TestUnion(long l); 
12. }; 
13.  
14. TestUnion::TestUnion(const char* ch) 
15. { 
16. 　　 data_.ch_ = ch; 
17. } 
18.  
19. TestUnion::TestUnion(long l) 
20. { 
21. 　　 data_.l_ = l; 
22. } 
23.  
24. int main (void) 
25. { 
26. 　　 return 0; 
27. } 

它完全是C风格的。

所以，接受这个结论吧:

请按照C中的convention去使用union，尽量不要尝试使用任何C++附加特性。

union是个好东西，union是个struct，里面所有成员共享一块内存，大小由size最大的member决定，存取成员的时候会以成员的类型来解析这块内存;在gamedev中，union可以在这些方面有所作为：

1. 换名：

1. struct Rename 
2. { 
3. public: 
4. union 
5. { 
6. struct 
7. { 
8. float x,y,z,w; 
9. }; 
10. struct 
11. { 
12. float vec[4]; 
13. }; 
14. }; 
15. }; 

这样我们既可以根据具体的含义来访问变量，也可以象数组一样的loop;

2 .压缩：

1. struct Compression 
2. { 
3. public: 
4. bool operator==(const Compression& arg) const { return value == arg.value; } 
5. union 
6. { 
7. struct 
8. { 
9. char a,b,c,d,e,f,g; 
10. }; 
11. struct 
12. { 
13. long long value; 
14. }; 
15. }; 
16. }; 

这样对于集中处理的情况，比如==，就会大幅度提高效率，象在64位机上，只要一次，或者传输数据的情况，压缩解压缩都非常方便;

3. 危险：

匿名的union用法，不是standard，所以在compiler上要确认==>编译器移植性不好;

不同的机器操作系统上数据的size都是不一样，表示不一样，那么在用union的时候，尤其是在移植的时候，都是危险的情况;

但是如果系统，compiler都是一样的话，在合适的地方使用union还是可以的。

联合(union)在C/C++里面见得并不多，但是在一些对内存要求特别严格的地方，联合又是频繁出现，那么究竟什么是联合、怎么去用、有什么需要注意的地方呢?就这些问题，我试着做一些简单的回答，里面肯定还有不当的地方，欢迎指出!

1、什么是联合?

“联合”是一种特殊的类，也是一种构造类型的数据结构。在一个“联合”内可以定义多种不同的数据类型， 一个被说明为该“联合”类型的变量中，允许装入该“联合”所定义的任何一种数据，这些数据共享同一段内存，已达到节省空间的目的(还有一个节省空间的类型：位域)。 这是一个非常特殊的地方，也是联合的特征。另外，同struct一样，联合默认访问权限也是公有的，并且，也具有成员函数。

2、联合与结构的区别?

“联合”与“结构”有一些相似之处。但两者有本质上的不同。在结构中各成员有各自的内存空间， 一个结构变量的总长度是各成员长度之和(空结构除外，同时不考虑边界调整)。而在“联合”中，各成员共享一段内存空间， 一个联合变量的长度等于各成员中最长的长度。应该说明的是， 这里所谓的共享不是指把多个成员同时装入一个联合变量内， 而是指该联合变量可被赋予任一成员值，但每次只能赋一种值， 赋入新值则冲去旧值。

下面举一个例了来加对深联合的理解。

例4:

1. #include <stdio.h> 
2. void main() 
3. { 
4. union number 
5. { /*定义一个联合*/ 
6. int i; 
7. struct 
8. { /*在联合中定义一个结构*/ 
9. char first; 
10. char second; 
11. }half; 
12. }num; 
13. num.i=0x4241; /*联合成员赋值*/ 
14. printf("%c%c/n", num.half.first, num.half.second); 
15. num.half.first='a'; /*联合中结构成员赋值*/ 
16. num.half.second='b'; 
17. printf("%x/n", num.i); 
18. getchar(); 
19. } 

输出结果为:

AB

6261

从上例结果可以看出: 当给i赋值后, 其低八位也就是first和second的值; 当给first和second赋字符后, 这两个字符的ASCII码也将作为i 的低八位和高八位。

3、如何定义?

例如：

1. union test 
2. { 
3. test() { } 
4. int office; 
5. char teacher[5]; 
6. }; 

定义了一个名为test的联合类型，它含有两个成员，一个为整型，成员名office;另一个为字符数组，数组名为teacher。联合定义之后，即可进行联合变量说明，被说明为test类型的变量，可以存放整型量office或存放字符数组teacher。

4、如何说明?

联合变量的说明有三种形式：先定义再说明、定义同时说明和直接说明。

以test类型为例，说明如下：

1)

1. union test 
2. { 
3. int office; 
4. char teacher[5]; 
5. };  
6. union test a,b; /*说明a,b为test类型*/ 

2)

1. union test 
2. { 
3. int office; 
4. char teacher[5]; 
5. } a,b; 

3)

1. union 
2. { 
3. int office; 
4. char teacher[5]; 
5. } a,b; 

经说明后的a,b变量均为test类型。a,b变量的长度应等于test的成员中最长的长度，即等于teacher数组的长度，共5个字节。a,b变量如赋予整型值时，只使用了4个字节，而赋予字符数组时，可用5个字节。

5、如何使用?

对联合变量的赋值，使用都只能是对变量的成员进行。联合变量的成员表示为：

联合变量名.成员名

例如，a被说明为test类型的变量之后，可使用a.class、a.office

不允许只用联合变量名作赋值或其它操作，也不允许对联合变量作初始化赋值，赋值只能在程序中进行。

还要再强调说明的是，一个联合变量，每次只能赋予一个成员值。换句话说，一个联合变量的值就是联合变员的某一个成员值。

6、匿名联合

匿名联合仅仅通知编译器它的成员变量共同享一个地址,而变量本身是直接引用的,不使用通常的点号运算符语法.

例如：

1. #include <iostream> 
2. void main() 
3. { 
4. union{  
5. int test; 
6. char c;  
7. };  
8. test=5; 
9. c='a'; 
10. std::cout<<i<<" "<<c; 
11. } 

正如所见到的,联合成分象声明的普通局部变量那样被引用,事实上对于程序而言,这也正是使用这些变量的方式.另外,尽管被定义在一个联合声明中,他们与同一个程序快那的任何其他局部变量具有相同的作用域级别.这意味这匿名联合内的成员的名称不能与同一个作用域内的其他一直标志符冲突.

对匿名联合还存在如下限制:

因为匿名联合不使用点运算符，所以包含在匿名联合内的元素必须是数据,不允许有成员函数，也不能包含私有或受保护的成员。还有,全局匿名联合必须是静态(static)的，否则就必须放在匿名名字空间中。

7、几点需要讨论的地方：

1)联合里面那些东西不能存放?

我们知道，联合里面的东西共享内存，所以静态、引用都不能用，因为他们不可能共享内存。

2)类可以放入联合吗?

我们先看一个例子：

1. class Test 
2. { 
3. public: 
4. Test():data(0) { } 
5. private: 
6. int data; 
7. }; 
8. typedef union _test 
9. { 
10. Test test;  
11. }UI;  

编译通不过，为什么呢?

因为联合里不允许存放带有构造函数、析够函数、复制拷贝操作符等的类，因为他们共享内存，编译器无法保证这些对象不被破坏，也无法保证离开时调用析够函数。

3)又是匿名惹的祸??

我们先看下一段代码：

1. class test 
2. { 
3. public: 
4. test(const char* p); 
5. test(int in); 
6. const operator char*() const {return 
7. data.ch;} 
8. operator long() const {return data.l;} 
9. private: 
10. enum type {Int, String }; 
11. union 
12. { 
13. const char* ch; 
14. int i; 
15. }datatype; 
16. type stype; 
17. test(test&); 
18. test& operator=(const test&); 
19. }; 
20. test::test(const char *p):stype 
21. (String),datatype.ch(p) { } 
22. test::test(int in):stype(Int),datatype.l(i) { 
23. } 

看出什么问题了吗?呵呵，编译通不过。为什么呢?难道datatype.ch(p)和datatype.l(i)有问题吗?

哈哈，问题在哪呢?让我们来看看构造test对象时发生了什么，当创建test对象时，自然要调用其相应的构造函数，在构造函数中当然要调用其成员的构造函数，所以其要去调用datatype成员的构造函数，但是他没有构造函数可调用，所以出

错。

注意了，这里可并不是匿名联合!因为它后面紧跟了个data!

4)如何有效的防止访问出错?

使用联合可以节省内存空间，但是也有一定的风险：通过一个不适当的数据成员获取当前对象的值!例如上面的ch、i交错访问。

为了防止这样的错误，我们必须定义一个额外的对象，来跟踪当前被存储在联合中的值得类型，我们称这个额外的对象为：union的判别式。

一个比较好的经验是，在处理作为类成员的union对象时，为所有union数据类型提供一组访问函数。

希望本文所述对大家的C++程序设计有所帮助。