Union

一、联合变量的说明

　　联合变量的说明和结构变量的说明方式相同, 也有三种形式。即先定义,再说明;定义同时说明和直接说明。以perdata类型为例,说明如下:  
union perdata
{
    int class;
    char officae;
};
union perdata a,b;
或者可同时说明为:  
union perdata
{  
int class;
char office;  
}a,b;
或直接说明为:  
union
{  
int class;
char office;  
}a,b  
经说明后的a,b变量均为perdata类型。 它们的内存分配示意图如图7—8所示。a,b变量的长度应等于 perdata 的成员中最长的长度, 即等于
office数组的长度,共10个字节。从图中可见,a,b变量如赋予整型值时,只使用了2个字节,而赋予字符数组时,可用10个字节。

联合变量的赋值和使用

　　对联合变量的赋值,使用都只能是对变量的成员进行。 联合变量的成员表示为: 联合变量名.成员名例如,a被说明为perdata类型的变量之后,可使用 a.class　a.office 不允许只用联合变量名作赋值或其它操作。也不允许对联合变量作初始化赋值,赋值只能在程序中进行?挂 偾康魉得鞯氖?一个联合变量, 每次只能赋予一个成员值?痪浠八?一个联合变量的值就是联合变员的某一个成员值。
[例7.15]设有一个教师与学生通用的表格,教师数据有姓名,年龄,职业,教研室四项。学生有姓名,年龄,职业,班级四项。
编程输入人员数据, 再以表格输出。
[code:1:8d8ee8c82c]
main()
{
    struct
    {
       char name[10];
       int age;
       char job;
       union
       {
          int class;
          char office[10];
       } depa;
    }body[2];
int n,i;
    for(i=0;i<2;i++)
    {
       printf("input name,age,job and department/n");
       scanf("%s %d %c",body[i].name,&body[i].age,&body[i].job);
       if(body[i].job=='s')
          scanf("%d",&body[i].depa.class);
       else
          scanf("%s",body[i].depa.office);
    }
    printf("name/tage job class/office/n");
    for(i=0;i<2;i++)
    {
    if(body[i].job=='s')
       printf("%s/t%3d %3c %d/n",body[i].name,body[i].age ,body[i].job,body[i].depa.class);
    else
       printf("%s/t%3d %3c %s/n",body[i].name,body[i].age, body[i].job,body[i].depa.office);
    }
}
[/code:1:8d8ee8c82c]
　　本例程序用一个结构数组body来存放人员数据, 该结构共有四个成员。其中成员项depa是一个联合类型, 这个联合又由两个成员组成,一个为整型量class,一个为字符数组office。在程序的第一个for语句中,输入人员的各项数据,先输入结构的前三个成员name,age和job,然后判别job成员项,如为"s"则对联合depa·class输入(对学生赋班级编号)否则对depa·office输入(对教师赋教研组名)。

　　在用scanf语句输入时要注意,凡为数组类型的成员,无论是结构成员还是联合成员,在该项前不能再加"&"运算符。如程序第18行中
body[i].name是一个数组类型,第22行中的body[i].depa.office也是数组类型,因此在这两项之间不能加"&"运算符。程序中的第二个for语句用于输出各成员项的值:

本章小结

1. 结构和联合是两种构造类型数据,是用户定义新数据类型的重要手段。结构和联合有很多的相似之处,它们都由成员组成。成员可以具有不同的数据类型。成员的表示方法相同。都可用三种方式作变量说明。

2. 在结构中,各成员都占有自己的内存空间,它们是同时存在的。一个结构变量的总长度等于所有成员长度之和。在联合中,所有成员不能同时占用它的内存空间,它们不能同时存在。联合变量的长度等于最长的成员的长度。

3. “.”是成员运算符,可用它表示成员项,成员还可用“->”运算符来表示。

4. 结构变量可以作为函数参数,函数也可返回指向结构的指针变量。而联合变量不能作为函数参数,函数也不能返回指向联合的指针变量。但可以使用指向联合变量的指针,也可使用联合数组。

5. 结构定义允许嵌套,结构中也可用联合作为成员,形成结构和联合的嵌套。

 

//----------------------------------------------------------------------------

#include
union myun
{
  struct
  {
    int x;
    int y;
    int z;
  }u;
  int k;
}a;
int main()
{
a.u.x =4;
a.u.y =5;
a.u.z =6;
a.k = 0;
printf("%d %d %d/n",a.u.x,a.u.y,a.u.z);
return 0;
}

联合变量的说明和结构变量的说明方式相同 , 也有三种形式。即先定义 , 再说明 ; 定义同时说明和直接说明。以 perdata 类型为例 , 说明如下 :

union perdata
{
int class;
char officae;
};
union perdata a,b;
或者可同时说明为 :
union perdata
{
int class;
char office;
}a,b;
或直接说明为 :
union
{
int class;
char office;
}a,b;

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

二、

联合(union)在C/C++里面见得并不多，但是在一些对内存要求特别严格的地方，联合又是频繁出现，那么究竟什么是联合、怎么去用、有什么需要注意的地方呢？就这些问题，我试着做一些简单的回答，里面肯定还有不当的地方，欢迎指出！
1、什么是联合？
   “联合”是一种特殊的类，也是一种构造类型的数据结构。在一个“联合”内可以定义多种不同的数据类型， 一个被说明为该“联合”类型的变量中，允许装入该“联合”所定义的任何一种数据，这些数据共享同一段内存，已达到节省空间的目的（还有一个节省空间的类型：位域）。 这是一个非常特殊的地方，也是联合的特征。另外，同struct一样，联合默认访问权限也是公有的，并且，也具有成员函数。

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

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

#include <stdio.h>
void main()
{
        union number
        {                   /*定义一个联合*/
                int i;
                struct
                {             /*在联合中定义一个结构*/
                        char first;
                        char second;
                }half;
        }num;
        num.i=0x4241;         /*联合成员赋值*/
        printf("%c%c\n", num.half.first, num.half.second);
        num.half.first='a';   /*联合中结构成员赋值*/
        num.half.second='b';
        printf("%x\n", num.i);
        getchar();
}
    输出结果为:
     AB
     6261
    从上例结果可以看出: 当给i赋值后, 其低八位也就是first和second的值; 当给first和second赋字符后, 这两个字符的ASCII码也将作为i 的低八位和高八位。

3、如何定义？
   例如：
    union test
    {
      test() { }
      int office;
      char teacher[5];
    };
    定义了一个名为test的联合类型，它含有两个成员，一个为整型，成员名office；另一个为字符数组，数组名为teacher。联合定义之后，即可进行联合变量说明，被说明为test类型的变量，可以存放整型量office或存放字符数组teacher。

4、如何说明？
   联合变量的说明有三种形式：先定义再说明、定义同时说明和直接说明。
   以test类型为例，说明如下：
    1) union test
       {
         int office;
         char teacher[5];
       };
       union test a,b;    /*说明a,b为test类型*/
    2) union test
       {
         int office;
         char teacher[5];
       } a,b;
    3) union
       {
         int office;
         char teacher[5];
       } a,b;
       经说明后的a,b变量均为test类型。a,b变量的长度应等于test的成员中最长的长度，即等于teacher数组的长度，共5个字节。a,b变量如赋予整型值时，只使用了4个字节，而赋予字符数组时，可用5个字节。

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

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

不允许只用联合变量名作赋值或其它操作，也不允许对联合变量作初始化赋值，赋值只能在程序中进行。
还要再强调说明的是，一个联合变量，每次只能赋予一个成员值。换句话说，一个联合变量的值就是联合变员的某一个成员值。

6、匿名联合
   匿名联合仅仅通知编译器它的成员变量共同享一个地址,而变量本身是直接引用的,不使用通常的点号运算符语法.例如：
     ＃i nclude <iostream>
     void main()
     {
         union{
                int test;
                char c;
               };         
        test=5;
        c=′a′;
        std::cout<<i<<" "<<c;
     }
    正如所见到的,联合成分象声明的普通局部变量那样被引用,事实上对于程序而言,这也正是使用这些变量的方式.另外,尽管被定义在一个联合声明中,他们与同一个程序快那的任何其他局部变量具有相同的作用域级别.这意味这匿名联合内的成员的名称不能与同一个作用域内的其他一直标志符冲突.
    对匿名联合还存在如下限制:
    因为匿名联合不使用点运算符，所以包含在匿名联合内的元素必须是数据,不允许有成员函数，也不能包含私有或受保护的成员。还有,全局匿名联合必须是静态(static)的，否则就必须放在匿名名字空间中。

7、几点需要讨论的地方：
   1、联合里面那些东西不能存放？
      我们知道，联合里面的东西共享内存，所以静态、引用都不能用，因为他们不可能共享内存。
   2、类可以放入联合吗？
      我们先看一个例子：
      class Test
      {
      public:
    Test():data(0) { }
      private:
          int data;
      };

     typedef union _test
     {
Test test;  
     }UI;  
     编译通不过，为什么呢？
     因为联合里不允许存放带有构造函数、析够函数、复制拷贝操作符等的类，因为他们共享内存，编译器无法保证这些对象不被破坏，也无法保证离开时调用析够函数。
    3、又是匿名惹的祸？？
       我们先看下一段代码：
class test
{
        public:
             test(const char* p);
             test(int in);
             const operator char*() const {return

data.ch;}
             operator long() const {return data.l;}
        private:
     enum type {Int, String };
            union
     {
const char* ch;
int i;
      }datatype;
      type stype;
      test(test&);
      test& operator=(const test&);
        };
       test::test(const char *p):stype

(String),datatype.ch(p)     { }
       test::test(int in):stype(Int),datatype.l(i)     {

}
     看出什么问题了吗？呵呵，编译通不过。为什么呢？难道datatype.ch(p)和datatype.l(i)有问题吗？
     哈哈，问题在哪呢？让我们来看看构造test对象时发生了什么，当创建test对象时，自然要调用其相应的构造函数，在构造函数中当然要调用其成员的构造函数，所以其要去调用datatype成员的构造函数，但是他没有构造函数可调用，所以出

错。
     注意了，这里可并不是匿名联合！因为它后面紧跟了个data!
    4、如何有效的防止访问出错？
       使用联合可以节省内存空间，但是也有一定的风险：通过一个不适当的数据成员获取当前对象的值！例如上面的ch、i交错访问。
       为了防止这样的错误，我们必须定义一个额外的对象，来跟踪当前被存储在联合中的值得类型，我们称这个额外的对象为：union的判别式。
       一个比较好的经验是，在处理作为类成员的union对象时，为所有union数据类型提供一组访问函数。