[C++11阅读][2-3-4]POD类型（下）

POD的好处

用is_pod::value可以判断是否是POD，头文件是#include 。
如果是POD，有以下好处。

1. 字节赋值
   代码中可以安全的使用memset和memcpy进行初始化和拷贝操作。
2. 内存布局与C兼容
   POD类型的数据在C和C++之间操作是安全的。
3. 保证了静态初始化的安全有效
   除了以上三点，后面还会列举POD的一个应用，非受限联合体。

非受限联合体

在C语言中，联合体union是很重要的一种数据结果，多种不同的数据类型共享同一个内存空间，可以达到节省空间的目的。
在C++中，不是所有类型都能成为联合体的成员。

#include 
using namespace std;
struct Student {
    Student(bool g, int a): gender(g), age(a){}
    bool gender;
    bool age;
};
union T {
    Student s;
    int id;
    char name[10];
};
int main(){}
// g++ cpp.cpp -o test，会编译失败，
// error: member ‘Student T::s’ with constructor not allowed in union
// note: unrestricted unions only available with -std=c++11 or -std=gnu++11

比如以上这段程序，用C++98编译会失败，用C++11可以。
C++98会判断Student是个非POD类型，不能放在union里，把自定义的构造函数去掉，在C++98中就可以了。
C++11没有这个限制，只要是非引用类型，都可以成为union的成员，称为”非受限联合体“。

非受限联合体的静态成员

C++11非受限联合体有个限制是，不允许静态成员变量存在，允许静态成员函数存在。联合体里的静态成员存在意义不大，此时union只能作为个namespace来用，例如以下程序。

#include 
using namespace std;
union T {
    static long Get() {
        return 32;
    }
};
int main() {
    cout << T::Get() << endl;
}
// 这个程序C++98也能编译通过
// 如果要带个静态成员变量，比如改成以下形式，C++98编译不过，换成C++11可以编译通过
union T {
    const static long L = 32;
    static long Get() {
        return L;
    }
};
// error: in C++98 ‘T::L’ may not be static because it is a member of a union
// 如果把const删掉，那C++11也编译不过

非受限联合体与构造函数

C++11非受限联合体的另一个限制是，如果成员类有非平凡的构造函数，会初始化失败，因为标准规定union会自动对未在初始化成员列表中的成员赋默认值，如果有非平凡构造函数，默认构造函数会被删除，union会因找不到默认构造函数而初始化失败，默认析构函数同理，例如以下程序，string有非平凡构造函数。

#include 
using namespace std;
union T {
    string s;
    int n;
};
int main() {
    T t;
}
// error: use of deleted function ‘T::T()’
// error: union member ‘T::s’ with non-trivial ‘std::__cxx11::basic_string<_CharT, _Traits, _Alloc>::basic_string() [with _CharT = char; _Traits = std::char_traits; _Alloc = std::allocator]’
// error: use of deleted function ‘T::~T()’
// error: union member ‘T::s’ with non-trivial ‘std::__cxx11::basic_string<_CharT, _Traits, _Alloc>::~basic_string() [with _CharT = char; _Traits = std::char_traits; _Alloc = std::allocator]’

解决办法是手动定义union的构造函数，去初始化各成员。采用placement new将s构造在其地址&s上。这样就能通过编译了。

#include 
using namespace std;
union T {
        string s;
        int n;
public:
        T() {
                new (&s) string;
        }
        ~T() {
                s.~string();
        }
};
int main() {
        T t;
}
// C++11可编译通过，C++98不行，会提示不允许string成员

匿名非受限联合体

匿名联合体可以直接访问成员名。在以下例子中，匿名联合体起到了“变长成员”的作用，节省空间，避免维护多个成员。

#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(){}
        private:
                Type t;
                union {
                        Student s;
                        int id;
                        char name[10];
                };
};
int main() {
        Singer(true, 13);
        Singer(310217);
        Singer("J Michael", 9);
}

不过我本人觉得书里的这个case不切实际，非要挤在一起，为何不拆成三个类。