现代C++语言核心特性解析part12_现代c++语言核心特性解析 电子版

第22章　类型别名和别名模板（C++11 C++14）

22.1 类型别名

往往会使用typedef为较长的类型名定义一个别名

typedef std::map<int, std::string>::const_iterator map_const_iter;
map_const_iter iter;
1
2

C++11标准提供了一个新的定义类型别名的方法，该方法使用using关键字，具体语法如下：

using identifier = type-id
1

这种表达式在定义函数指针类型的别名时显得格外清晰：

typedef void(*func1)(int, int);
using func2 = void(*)(int, int);
1
2

22.2 别名模板

所谓别名模板本质上也应该是一种模板，它的实例化过程是用自己的模板参数替换原始模板的模板参数，并实例化原始模板。：

template < template-parameter-list >
using identifier = type-id;
1
2

下面来看一个例子：

#include <map>
#include <string>
template<class T>
using int_map = std::map<int, T>;
int main()
{
	int_map<std::string> int2string;
	int2string[11] = "7";
}
1
2
3
4
5
6
7
8
9

有模板元编程经验的读者可能会提出typedef其实也能做到相同的事情。没错，我们是可以用typedef来改写上面的代码：

#include <map>
#include <string>
template<class T>
struct int_map {
	typedef std::map<int, T> type;
};
int main()
{
	int_map<std::string>::type int2string;
	int2string[11] = "7";
}
1
2
3
4
5
6
7
8
9
10
11

不仅要定义一个int_map的结构体类型，还需要在类型里使用typedef来定义目标类型，最后必须使用int_map< std::string>::type来声明变量。除此之外，如果遇上了待决的类型，还需要在变量声明前加上typename关键字：

template<class T>
struct int_map {
	typedef std::map<int, T> type;
};
template<class T>
struct X {
	typename int_map<T>::type int2other; // 必须带有typename关键字，否则编译错误
};
1
2
3
4
5
6
7
8

类模板X没有确定模板形参T的类型，所以int_map< T >::type是一个未决类型，也就是说int_map< T >::type既有可能是一个类型，也有可能是一个静态成员变量，编译器是无法处理这种情况的。这里的typename关键字告诉编译器应该将int_map::type作为类型来处理。而别名模板不会有::type的困扰，当然也不会有这样的问题了：

template<class T>
using int_map = std::map<int, T>;
template<class T>
struct X {
	int_map<T> int2other; // 编译成功，别名模板不会有任何问题
};
1
2
3
4
5
6

在C++14标准库中模板元编程函数已经有了别名模板的版本。当然，为了保证与老代码的兼容性，typedef的方案依然存在。别名模板的模板元编程函数使用_t作为其名称的后缀以示区分：

template<bool _Cond, typename _Tp = void>
using enable_if_t = typename enable_if<_Cond, _Tp>::type;
1
2

第23章　指针字面量nullptr（C++11）

23.1 零值整数字面量

NULL是一个宏，在C++11标准之前其本质就是0：

#ifndef NULL
	#ifdef __cplusplus
		#define NULL 0
	#else
		#define NULL ((void *)0)
	#endif
#endif
1
2
3
4
5
6
7

使用0代表不同类型的特殊规则给C++带来了二义性

void f(int)
{
	std::cout << "int" << std::endl;
}
void f(char *)
{
	std::cout << "char *" << std::endl;
}
f(NULL);
f(reinterpret_cast<char *>(NULL));
1
2
3
4
5
6
7
8
9
10

在上面这段代码中f(NULL)函数调用的是f(int)函数，因为NULL会被优先解析为整数类型。没有办法让编译器自动识别传入NULL的意图，除非使用类型转换，将NULL转换到char*，f(reinterpret_cast<char >(NULL))可以正确地调用f(char)函数。

std::string s1(false);
std::string s2(true);
1
2

23.2 nullptr关键字

C++标准委员会在C++11中添加关键字nullptr表示空指针的字面量，它是一个std::nullptr_t类型的纯右值。它还可以隐式转换为各种指针类型，但是无法隐式转换到非指针类型。

char* ch = nullptr;
char* ch2 = 0;
assert(ch == 0);
assert(ch == nullptr);
assert(!ch);
assert(ch2 == nullptr);
assert(nullptr == 0);

//全部编译通过
1
2
3
4
5
6
7
8
9

nullptr可以和0进行比较，但这并不代表它的类型为整型，同时它也不能隐式转换为整型：

int n1 = nullptr;
char* ch1 = true ? 0 : nullptr;
int n2 = true ? nullptr : nullptr;
int n3 = true ? 0 : nullptr;
1
2
3
4

第一句和第三句操作都是将一个std::nullptr_t类型赋值到int类型变量。由于这个转换并不能自动进行，因此会产生编译错误。而第二句和第四句中，因为条件表达式的 :前后类型不一致，而且无法简单扩展类型，所以同样会产生编译错误。

nullptr的类型std::nullptr_t，它并不是一个关键字，而是使用decltype将nullptr的类型定义在代码中，C++标准规定该类型的长度和void *相同：

namespace std
{
	using nullptr_t = decltype(nullptr);
	// 等价于
	typedef decltype(nullptr) nullptr_t;
}
static_assert(sizeof(std::nullptr_t) == sizeof(void *));
1
2
3
4
5
6
7

nullptr是一个纯右值，而其他两个是左值：

std::nullptr_t null1, null2;
std::cout << "&null1 = " << &null1 << std::endl; // null1和null2是左值，可以成功获取对象指针，
std::cout << "&null2 = " << &null2 << std::endl; // 并且指针指向的内存地址不同
std::cout << "&nullptr = " << &nullptr << std::endl; // 编译失败，取地址操作需要一个左值
1
2
3
4

我们可以为函数模板或者类设计一些空指针类型的特化版本

#include <iostream>
template<class T>
struct widget
{
	widget()
	{
		std::cout << "template" << std::endl;
	}
};
template<>
struct widget<std::nullptr_t>
{
	widget()
	{
		std::cout << "nullptr" << std::endl;
	}
};
template<class T>
widget<T>* make_widget(T)
{
	return new widget<T>();
}
int main()
{
	auto w1 = make_widget(0);
	auto w2 = make_widget(nullptr);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

第24章　三向比较（C++20）

24.1 “太空飞船”（spaceship）运算符

三向比较就是在形如lhs <=> rhs的表达式中，两个比较的操作数lhs和rhs通过<=>比较可能产生3种结果，该结果可以和0比较，小于0、等于0或者大于0分别对应lhs < rhs、lhs == rhs和lhs > rhs。

bool b = 7 <=> 11 < 0; // b == true
1

运算符<=>的返回值只能与0和自身类型来比较，如果同其他数值比较，编译器会报错：

bool b = 7 <=> 11 < 100; // 编译失败，<=>的结果不能与除0以外的数值比较
1

24.2 三向比较的返回类型

根据标准三向比较会返回3种类型，分别为std::strong_ordering、std::weak_ordering以及std:: partial_ordering

24.2.1 std::strong_ordering

std::strong_ordering类型有3种比较结果，分别为std::strong_ ordering::less、std::strong_ordering::equal以及std::strong_ordering::greater。表达式lhs <=> rhs分别表示lhs <rhs、lhs == rhs以及lhs > rhs。std::strong_ordering类型的结果强调的是strong的含义，表达的是一种可替换性，简单来说，若lhs == rhs，那么在任何情况下rhs和lhs都可以相互替换，也就是fx(lhs) == fx(rhs)。
对于基本类型中的int类型，三向比较返回的是std::strong_ordering

std::cout << typeid(decltype(7 <=> 11)).name();
1

对于有复杂结构的类型，std::strong_ordering要求其数据成员和基类的三向比较结果都为std::strong_ordering。

#include <compare>
struct B
{
	int a;
	long b;
	auto operator <=> (const B&) const = default;
};
struct D : B
{
	short c;
	auto operator <=> (const D&) const = default;
};
D x1, x2;
std::cout << typeid(decltype(x1 <=> x2)).name();
1
2
3
4
5
6
7
8
9
10
11
12
13
14

24.2.2　std::weak_ordering

std::weak_ordering类型也有3种比较结果，分别为std::weak_ ordering::less、
std::weak_ordering::equivalent以及std::weak_ordering::greater。std::weak_ordering的含义正好与std::strong_ ordering相对，表达的是不可替换性。即若有lhs== rhs，则rhs和lhs不可以相互替换，也就是fx(lhs) !=fx(rhs)。这种情况在基础类型中并没有，但是它常常发生在用户自定义类中

#include <compare>
#include <string>
int ci_compare(const char* s1, const char* s2)
{
	while (tolower(*s1) == tolower(*s2++)) {
		if (*s1++ == '\0') {
			return 0;
		}
	}
	return tolower(*s1) - tolower(*--s2);
}
class CIString {
public:
	CIString(const char *s) : str_(s) {}
	std::weak_ordering operator<=>(const CIString& b) const {
		return ci_compare(str_.c_str(), b.str_.c_str()) <=> 0;
	}
private:
	std::string str_;
};
CIString s1{ "HELLO" }, s2{"hello"};
std::cout << (s1 <=> s2 == 0); // 输出为true
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

当std::weak_ordering和std::strong_ ordering同时出现在基类和数据成员的类型中时，该类型的三向比较结果是std::weak_ordering

struct D : B
{
	CIString c{""};
	auto operator <=> (const D&) const = default;
};
D w1, w2;
std::cout << typeid(decltype(w1 <=> w2)).name();
1
2
3
4
5
6
7

24.2.3　std::partial_ordering

std::partial_ordering类型有4种比较结果，分别为std::partial_ ordering::less、std::partial_ordering::equivalent、std::partial_ordering::greater以及std::partial_ordering::unordered。std::partial_ordering约束力比std::weak_ordering更弱，它可以接受当lhs == rhs时rhs和lhs不能相互替换，同时它还能给出第四个结果std::partial_ ordering::unordered，表示进行比较的两个操作数没有关系。

std::cout << typeid(decltype(7.7 <=> 11.1)).name();
1

会输出classstd::partial_ordering而不是std::strong_ordering，是因为浮点的集合中存在一个特殊的NaN，它和其他浮点数值是没关系的：

std::cout << ((0.0 / 0.0 <=> 1.0) == std::partial_ordering::unordered);
1

当std::weak_ordering和std:: partial_ordering同时出现在基类和数据成员的类型中时，该类型的三向比较结果是std::partial_ordering

struct D : B
{
	CIString c{""};
	float u;
	auto operator <=> (const D&) const = default;
};
D w1, w2;
std::cout << typeid(decltype(w1 <=> w2)).name();
1
2
3
4
5
6
7
8

在C++20的标准库中有一个模板元函数std::common_comparison_category，它可以帮助我们在一个类型合集中判断出最终三向比较的结果类型，当类型合集中存在不支持三向比较的类型时，该模板元函数返回void。

24.3　对基础类型的支持

1．对两个算术类型的操作数进行一般算术转换，然后进行比较。其中整型的比较结果为std::strong_ordering，浮点型的比较结果为std::partial_ordering。
2．对于无作用域枚举类型和整型操作数，枚举类型会转换为整型再进行比较，无作用域枚举类型无法与浮点类型比较：

enum color {
	red
};
auto r = red <=> 11; //编译成功
auto r = red <=> 11.1; //编译失败
1
2
3
4
5

3．对两个相同枚举类型的操作数比较结果，如果枚举类型不同，则无法编译。
4．对于其中一个操作数为bool类型的情况，另一个操作数必须也是bool类型，否则无法编译。比较结果为std::strong_ordering。
5．不支持作比较的两个操作数为数组的情况，会导致编译出错，例如

int arr1[5];
int arr2[5];
auto r = arr1 <=> arr2; // 编译失败
1
2
3

6．对于其中一个操作数为指针类型的情况，需要另一个操作数是同样类型的指针，或者是可以转换为相同类型的指针，比如数组到指针的转换、派生类指针到基类指针的转换等，最终比较结果为std::strong_ordering：

char arr1[5];
char arr2[5];
char* ptr = arr2;
auto r = ptr <=> arr1;
1
2
3
4

24.4　自动生成的比较运算符函数

C++20标准规定，如果用户为自定义类型声明了三向比较运算符，那么编译器会为其自动生成<、>、<=和>=这4种运算符函数。
在提案文档p1190中提出了一个严重的性能问题。简单来说，假设有一个结构体：

struct S {
	std::vector<std::string> names;
	auto operator<=>(const S &) const = default;
};
1
2
3
4

它的三向比较运算符的默认实现这样的：

template<typename T>
std::strong_ordering operator<=>(const std::vector<T>& lhs, const std::vector<T> & rhs)
{
	size_t min_size = min(lhs.size(), rhs.size());
	for (size_t i = 0; i != min_size; ++i) {
		if (auto const cmp = std::compare_3way(lhs[i], rhs[i]); cmp != 0) {
			return cmp;
		}
	}
	return lhs.size() <=> rhs.size();
}
1
2
3
4
5
6
7
8
9
10
11

对于<和>这样的运算符函数没有问题，因为需要比较容器中的每个元素。但是==运算比较低效，高效的做法是先比较容器中的元素数量是否相等，如果元素数量不同，则直接返回false：

template<typename T>
bool operator==(const std::vector<T>& lhs, const std::vector<T>& rhs)
{
	const size_t size = lhs.size();
	if (size != rhs.size()) {
		return false;
	}
	for (size_t i = 0; i != size; ++i) {
		if (lhs[i] != rhs[i]) {
		 return false;
		}
	}
	return true;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

对于== 和!=两种比较运算符函数，只需要多声明一个==运算符函数，!=运算符函数会根据前者自动生成：

class CIString {
public:
	CIString(const char* s) : str_(s) {}
	std::weak_ordering operator<=>(const CIString& b) const {
		return ci_compare(str_.c_str(), b.str_.c_str()) <=> 0;
	}
	bool operator == (const CIString& b) const {
		return ci_compare(str_.c_str(), b.str_.c_str()) == 0;
	}
private:
	std::string str_;
};
CIString s1{ "hello" }, s2{ "world" };
bool r1 = s1 >= s2; // 调用operator<=>
bool r2 = s1 == s2; // 调用operator ==
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

24.5　兼容旧代码

在用户自定义类型中，实现了<、==运算符函数的数据成员类型，在该类型的三向比较中将自动生成合适的比较代码。

struct Legacy {
	int n;
	bool operator==(const Legacy& rhs) const
	{
		return n == rhs.n;
	}
	bool operator<(const Legacy& rhs) const
	{
		return n < rhs.n;
	}
};
struct TreeWay {
	Legacy m;
	std::strong_ordering operator<=>(const TreeWay &) const = default;
};
TreeWay t1, t2;
bool r = t1 < t2;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在上面的代码中，结构体TreeWay的三向比较操作会调用结构体Legacy中的<和==运算符来完成