10 C++11 非受限联合体

声明：该文章转载自此篇文章，欢迎大家支持关注原作者！

1. 受限联合体

一个联合体内，可以定义多种不同数据类型的成员，这些数据成员将会共享相同内存空间，在一些需要复用内存的情况下，可以达到节省空间的目的。
不过，根据C++98标准，并不是所有的数据类型都能够成为联合体的数据成员。如下代码：

struct Student
{
    Student(bool g, int a) : gender(g), age(a) {}

    bool gender;
    int age;
};

union T
{
    Student s; // 编译失败，Student不是一个POD类型
    int id;
    char name[10];
};

声明了一个Student的类型。根据之前POD类型的知识，由于Student自定义了一个构造函数，所以该类型是非POD类型的。

在C++98标准中，union T是无法通过编译的。事实上，除了非POD类型之外，C++98标准也不允许联合体拥有静态或引用类型的成员。

这样虽然可能在一定程度上保证了和C的兼容性，不过也为联合体的使用带来了很大的限制。

2. 非受限联合体

在C++11标准中，取消了联合体对于数据成员类型的限制。

标准规定，任何非引用类型都可以成为联合体的数据成员，而这样的联合体即所谓非受限联合体（Unrestricted Union）。

（1）非受限联合体中的静态成员（静态成员变量和静态成员函数）

联合体拥有静态成员（在非匿名联合体中）的限制，也在C++11新标准中被删除了。

不过从实践中，发现C++11的规则不允许静态成员变量的存在（否则所有该类型的联合体将共享一个值）。

而静态成员函数存在的唯一作用，大概就是为了返回一个常数，如下示例：

#include 
using namespace std;

union T
{
    static long Get() { return 2020; }
};

int main()
{
    cout << T::Get() << endl; // 2020
}

定义了一个有静态成员函数的联合体，不过看起来这里的union T更像是一个作用域限制符，并没有太大的实用意义。

（2）非受限联合体的初始化

C++98标准规定，联合体会自动对未在初始化成员列表中出现的成员赋默认初值。

然而对于联合体而言，这种初始化常常会带来疑问，因为在任何时刻只有一个成员可以是有效的。如下示例：

union T
{
    int x;
    double d;
    char b[sizeof(double)];
};

T t = { 0 }; // 到底是初始化第一个成员还是所有成员呢?

使用了花括号组成的初始化列表，试图将成员变量x初始化为零，即整个联合体的数据t中低位的4字节被初始化为0，然而实际上，t所占的8个字节将全部被置0。

而在C++11中，为了减少这样的疑问，标准会默认删除一些非受限联合体的默认函数。

比如，非受限联合体有一个非POD的成员，而该非POD成员类型拥有非平凡的构造函数，那么非受限联合体成员的默认构造函数将被编译器删除。

其他的特殊成员函数，例如默认拷贝构造函数、拷贝赋值操作符以及析构函数等，也将遵从此规则。
如下示例：

#include 
using namespace std;

union T
{
    string s; // string有非平凡的构造函数
    int n;
};

int main()
{
    T t; // 构造失败，因为T的构造函数被删除; ERROR:尝试引用已删除的函数
}

联合体T拥有一个非POD的成员变量s。而string却有非平凡的构造函数，因此T的构造函数被删除，其类型的变量t也就无法声明成功。

解决这个问题的办法：由程序员自己为非受限联合体定义构造函数。通常情况下，placement new会发挥很好的作用，改为如下：

#include 
using namespace std;

union T
{
    string s; // string有非平凡的构造函数
    int n;
public:
    T() { new (&s) string; }  // 自定义构造函数
    ~T() { s.~string(); }     // 自定义析构函数
};

int main()
{
    T t; // 编译通过
}

自定义了union T的构造和析构函数。构造时，采用placement new将s构造在其地址&s上。这里placement new的唯一作用只是调用了一下string的构造函数。

而在析构时，又调用了string的析构函数。

必须注意的是，析构的时候union T也必须是一个string对象，否则可能导致析构的错误（或者让析构函数为空，至少不会造成运行时错误）。

这样一来，变量t的声明就可以通过编译。

3. 匿名非受限联合体

匿名非受限联合体可以运用于类的声明中，这样的类也称为“枚举式的类”。如下示例：

#include 
#include 
using namespace std;

struct Student
{
    Student(bool g, int a) : gender(g), age(a) {}

    bool gender;
    int age;
};

class Singer
{
public:
    enum Type { STUDENT, NATIVE, FOREIGNER };
    Singer(bool g, int a) : s(g, a)
    {
        t = STUDENT;
    }
    Singer(int i) : id(i)
    {
        t = NATIVE;
    }
    Singer(const char* n, int s)
    {
        int size = (s > 9) ? 9 : s;
        memcpy(name, n, size);
        name[s] = '\0';
        t = FOREIGNER;
    }
    ~Singer() {}
    void print()
    {
        switch (t)
        {
        case STUDENT:
            cout << "s.gender: " << s.gender << endl;
            cout << "s.age: " << s.age << endl;
            break;
        case NATIVE:
            cout << "id: " << id << endl;
            break;
        case FOREIGNER:
            cout << "name: " << name << endl;
            break;
        default:
            break;
        }
    }
private:
    Type t;
    union
    {
        Student s;
        int id;
        char name[10];
    };
};

int main()
{
    Singer objSer1(true, 13);
    objSer1.print();

    Singer objSer2(20200129);
    objSer2.print();

    Singer objSer3("kaizenliu", 9);
    objSer3.print();

    system("pause");
}

/*运行结果
s.gender: 1
s.age: 13
id: 20200129
name: kaizenliu
*/

把匿名非受限联合体成为类Singer的“变长成员”（variant member）。可以看到，这样的变长成员给类的编写带来了更大的灵活性。

4. 附录

placement new：

定义：
placement new就是在用户指定的内存位置上（这个内存是已经预先分配好的）构建新的对象，因此这个构建过程不需要额外分配内存，只需要调用对象的构造函数在该内存位置上构造对象即可。
语法：

Object * p = new (address) ClassConstruct(...);

address：placement new所指定的内存地址
ClassConstruct：对象的构造函数
优点：
在已分配好的内存上进行对象的构建，构建速度快
已分配好的内存可以反复利用，有效的避免内存碎片问题
示例：

//先分配一对内存
int* buff = new int;
memset(buff,0,sizeof(int));
 
//此处new的placement new，在buff的内存上构造int对象，不需要分配额外的内存
int *p = new (buff)int(3);
 
std::cout << *p << std::endl; //3