第八章 结构、联合与枚举

• 8.3 联合
• • 8.3.1 联合和类
  • 8.3.2 匿名union

8.3 联合

union是一种特殊的struct，它的所有成员都分配在同一个地址空间上。因此，一个union实际占用的空间大小与其最大的成员一样。自然地，在同一时刻union只能保存一个成员的值。例如，考虑一个符号表项存放名字和值对的情况：

enum Type{str, num};

struct Entry{
	char* name;
	Type t;
	char* s;			//如果t == str，使用s
	int i;				//如果t == num，使用i
};

void f(Entry* p)
{
	if(p->t == str)
		cout << p->s;
	//...
}

在这个例子中，成员s和i永远不会被同时使用，因此空间都浪费了。我们可以把它们指定成union的成员，以解决上述问题：

union Value{
	char* s;
	int i;
};

语言本身并不负责追踪和管理union到底存的是哪些值，这是程序员的责任：

struct Entry{
	char* name;
	Type t;
	Value v;			//如果 t==str，使用v.s；如果t==num，使用v.i
};

void f(Emtry* p)
{
	if(p->t == str)
		cout << p->v.s;
	//...
}

为了避免可能出现的错误，程序员最好把union封装起来，从而确保访问union成员的方式与该成员的类型永远保持一致（见8.3.2节）。

联合有时候会被误用于“类型转换”的目的。这种误用的情况常常发生在一些特定的程序员身上，他们曾经使用的编程语言缺少显式类型转换的功能，因此不得不采用这种方式。例如，下面所示的 int 向 int* 的“转换”以这两种类型逐位等价为前提：

union Fudge{
	int i;
	int* p;
};

int* cheat(int i)
{
	Fudge a;
	a.i = i;
	return a.p;	//错误的用法
}

这根本算不上是一种类型转换。在一些机器环境中，int和int*占用的空间大小并不一样；而在另外一些机器中，整数的地址不能是奇数。因此，像这样使用union不但危险，而且无法移植。如果你确实需要类似的转换，最好使用显式类型转换符（见11.5.2节），这样读者就能清楚地知道到底发生了什么。例如：

int* cheat2(int i)
{
	return reinterpret_cast<int*>(i);		//显然这个转换本身既不美观，也很容易出错
}

无论如何，在上面的代码中，如果转换前后对象的尺寸不一致，那么编译器至少有机会给出报错信息；它比使用union的版本强多了。

使用union的目的无非是让数据更紧密，从而提高程序的性能。然而，大多数程序即使用了union也不会提高太多；同时，使用union的代码更容易出错。因此，我认为union是一种被过度使用的语言特性，最好不要出现在你的程序中。

8.3.1 联合和类

在很多非平凡的union中，存在一个不太常用的成员，它的尺寸比其他常用成员的尺寸都大得多。因为union的尺寸与它最大的成员一样大，所以避免地存在空间浪费的情况。我们可以使用一组派生类（见3.2.2节和第20章）代替union，从而避免空间的浪费。

从技术上来说，union是一种特殊的struct（见8.2节），而struct是一种特殊的class（第16章）。然而，很多提供给类的功能与联合无关，因此对union施加了一些限制：

1. union不能含有虚函数
2. union不能含有引用类型的成员
3. union不能含有基类
4. 如果union的成员含有用户自定义的构造函数、拷贝操作、移动操作或者析构函数，则此类函数对于union来说被delete掉了（见3.3.4节和17.6.4节）。换句话说，union类型的对象不能含有这些函数
5. 在union的所有成员中，最多只能有一个成员含类内初始化器（见17.4.4节）
6. union不能被用作其他类的基类

这些约束规则有效地阻止了很多错误的发生，同时简化了union的实现过程。后面一点非常重要，因为union的主要作用是优化代码的性能，所以我们肯定不希望在使用union的过程中引入“隐形的代价”。

如果union的成员含有构造函数（及其他），则必须delete掉这些函数。这条规则使得简单的union使用起来确实简单。如果需要用到更复杂的操作，那么由程序员来实现。例如，因为Entry的成员不含构造函数、析构函数及赋值操作，所以我们能自由地创建Entry的副本：

void f(Entry a)
{
	Entry b = a;
};

如果对一个复杂的union执行同样的操作，则不仅实现起来很难，而且容易出错：

union U{
	int m1;
	complex<double> m2;			//复数含有构造函数
	string m3;					//string含有构造函数（维护一个重要的不变量）
};

要想拷贝U，程序员必须决定使用哪个拷贝操作。例如：

void f2(U x)
{
	U u;					//错误：哪个默认构造函数？
	U u2 = x;				//错误：哪个拷贝构造函数？
	u.m1 = 1;				//给int成员赋值
	string s = u.m3;		//程序灾难：从string成员中读取内容
	return;					//错误：x、u和u2使用的是哪个析构函数？
}

一般来说，先把值写入某个成员然后读取另一个成员的值通常是非法的，但是人们常常忽略这一点（从而产生了错误）。在此例中，程序以无效实参调用了string的拷贝构造函数。程序员应该庆幸这段代码无法通过编译，否则后果不堪设想。如果确实需要，用户可以定义一个包含union的类，该类可以正确地处理union中含有构造函数、析构函数和赋值操作（见8.3.2节）的成员。同时，该类还能防止先把值写入某个成员然后读取另一个成员的错误。

C++允许为联合的最多一个成员指定类内初始化器。此时，该初始化器被用于默认初始化。例如：

union U2{
	int a;
	const char* p{“”};
};

U2 x1;			//执行默认初始化，使得x1.p == “”
U2 x2{7};		//x2.a == 7

8.3.2 匿名union

下面的程序建立了Entry（见8.3节）的一个变形，从中可以看出如何编写一个类来解决误用union带来的问题：

class Entry2{
private:
	enum class Tag{number, text};
	Tag type;	//判别式

	union{		//表示形式
		int i;
		string s;			//string有默认构造函数、拷贝操作及析构函数
	};
public:
	struct Bad_entry{ };	//用于处理异常

	string name;

	~Entry2{};
	Entry2& operator=(const Entry2&);		//因为存在string变量，所以是必需的
	Entry2(const Entry2&);
	//...

	int number() const;
	string text() const;

	void set_number(int n);
	void set_text(const string&);
	//...
};

我不是get/set函数的拥趸，但是在这个例子中，我们确实需要为每种访问操作自定义非平凡的形式。我用Tag的取值为“get”函数命名，并且在“set”函数前加上set_前缀。这是一种我自己比较习惯的命名方式。

执行读操作的函数的定义如下所示：

int Entry2::number() const{
	if(type!=Tag::number)throw Bad_entry{};
		return i;
};

string Entry2::text() const
{
	if(type!=Tag::text) throw Bad_entry();
		return s;
};

这两个访问函数首先检查type标签，如果是我们想执行的访问，则返回对应值的引用；否则，抛出异常。这样的union称为标签联合（tagged union）或者可判别联合（discriminated union）。

执行写操作的函数检查type标签的方式与执行读操作的函数基本相同，但是在设置新值的时候必须考虑之前的值的情况：

void Entry2::set_number(int n)
{
	if(type == Tag::text){
		s.~string();		//显式地销毁string（见11.2.4节）
		type = Tag::number;
	}
	i = n;
}

void Entry2::set_text(const string& ss)
{
	if(type == Tag::text)
		s = ss;
	else{
		new(&s) string{ss};	//new的作用是显式地构造string（见11.2.4节）
		type = Tag::text;
	}
}

union的用法使得我们必须用其他一些晦涩的、底层的语言特性（显式构造函数和析构函数）来管理union的元素的生命周期。这是应该避免使用union的另一个原因。

在Entry2中声明的union没有命名，它是一个匿名联合（anonymous union）。匿名联合是一个对象而非一种类型，我们无须对象名就能直接访问它的成员。因此，我们使用匿名联合的成员的方式与使用类成员的方式完全一样，只要谨记同一时刻只能使用union的一个成员就可以了。

Entry2含有一个string类型的成员，而在string类型中有用户自定义的赋值运算符，因此Entry2的赋值运算符被delete掉了（见3.3.4节和17.6.4节）。要想为Entry2的对象赋值，就必须先定义Entry2::operator=()。赋值运算兼具读/写两种操作的复杂性，但是它在逻辑上与访问函数很相似：

Entry2& Entry2::operator=(const Entry2& e)	//因为存在string变量，所以是必需的
{
	if(type == Tag::text && e.type == Tag::text){
		s = e.s;		//常规的string赋值
		return *this;
	}

	if(type == Tag::text) s.~string();		//显式地销毁（见11.2.4节）

	switch(e.type){
	case Tag::number:
		i = e.i;
		break;
	case Tag::text:
		new(&s)(e.s);	//new的作用是显式地构造string（见11.2.4节）
		type = e.type;
	}

	return *this;
}

构造函数与移动赋值操作的定义方式可以很类似。我们至少需要一到两个构造函数来建立type标签和值之间的对应关系。析构函数必须能处理string类型：

Entry2::~Entry2()
{
	if(type == Tag::text) s.~string();	//显式地销毁（见11.2.4节）
}

标签：Entry2,8.3,string,union,C++,int,枚举,type,构造函数
来源： https://blog.csdn.net/qq_40660998/article/details/122105923