（十七）标准库特殊设施

1 四个标准库设施

• tuple
• bitset
• 随机数生成
• 正则表达式
• IO库再探

2 tuple类型

• 类似pair模板，保存一定数量的不同成员类型的成员。
• 头文件#include

2.1定义及初始化

• 定义tuple时需要指出成员类型，由于构造函数是explicit的，必须使用直接初始化语法：

	std::tuple<size_t, size_t, size_t> threeD{ 1,2,3 }; //直接初始化
	auto user = std::make_tuple("hh", 160, 90.2); //生成tuple类型对象，根据初始值推断类型
1
2

2.2访问

• tuple对象都是未命名的，要通过get函数访问tuple类型成员。计数从0开始。

	//访问
	auto username = std::get<0>(user);  //尖括号内只能用整型常量表达式
	std::cout << username << std::endl;
	//tuple成员修改
	std::get<0>(user) = "xx";
	std::cout << std::get<0>(user) << std::endl;  
	//通过指针修改
	auto* usernamep = &(std::get<0>(user));  
	* usernamep = "aa";
	std::cout << std::get<0>(user) << std::endl;
	//获得成员类型
	typedef decltype(user) userstype;
	std::tuple_element<1, userstype>::type cnt = std::get<1>(user); //int cnt,cnt类型与item中第二个成员相同
	//获得成员数量
	size_t sz = std::tuple_size<userstype>::value;
	std::cout << sz << std::endl;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2.3比较

当对应运算符操作合法且两个tuple类型对象成员数量相同时，可以使用关系运算符和相等运算符进行比较操作。

2.4使用

• 通过tuple函数，可以从一个函数中返回多个值并进行处理

#include
#include
#include
#include

typedef std::tuple<std::string, size_t, double> hhtype;

class hhdy{
public:
	friend class hhdyvec;
	hhdy(std::string s = "", size_t count = 0,double p= 0.0):name(s),cnt(count),price(p){}
	std::string getname() { return this->name; }
	hhtype get_tuple() { return std::make_tuple(name, cnt, price); }
private:
	std::string name;
	size_t cnt;
	double price;
};


class hhdyvec {
public:
	friend std::vector<hhtype> get_record_of_book(std::string& s, hhdyvec& hv);
	hhdyvec() {};
	hhdyvec(std::vector<hhdy> v):vech(v){}

	hhdyvec& push_back(hhdy h) {
		vech.push_back(h);
		return *this;
	}

private:
	std::vector<hhdy> vech;
};

//返回hhdyvec中指定名字的tuple类型对象

std::vector<hhtype> get_record_of_book(std::string& s, hhdyvec& hv) {
	std::vector<hhtype> ret;
	for (hhdy h : hv.vech) {
		if (h.getname() == s)
			ret.push_back(h.get_tuple());
	}
	return ret;
}
//打印
std::ostream& print_record_of_book(std::istream& is,std::ostream& os, hhdyvec& hv) {
	std::string s;
	os << "输入书名: ";
	is >> s;
	std::vector<hhtype> ret = get_record_of_book(s, hv);
	size_t st = std::tuple_size<hhtype>::value;
	for (hhtype h : ret) {
			os <<"bookname: "<<std::get<0>(h)
				<<" count: "<<std::get<1>(h)
				<<" price: "<<std::get<2>(h)
				<< std::endl;
	}
	return os;
}

std::ostream& print_books(std::istream& is, std::ostream& os, hhdyvec& hv) {
	std::string s;
	do {
		print_record_of_book(is, os, hv);
		os << "continue ?(y/n)";

		is >> s;
	} while (s == "y" || s == "Y");
	return os;

}

int main() {
	hhdyvec hv;
	hhdy h1 = hhdy("book1", 1, 10);
	hhdy h2 = hhdy("book2", 2, 20);
	hv.push_back(h1);
	hv.push_back(h2);
	hv.push_back(h2);
	print_books(std::cin, std::cout, hv);
	return 0;
}
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

3bitset类型

• 除内置运算符外，标准库还定义了bitset类，使位运算使用更容易。能处理超过最长整形类型大小的位集合。
• 头文件#include

3.1定义及初始化

• 定义bitset时，要声明他用多少位，大小是一个常量表达式。
• 二进制位从0开始编号，编号从0开始称为低位，到结束为高位。

	//使用整型值来初始化bitset时，只会被转换为unsigned long long类型处理。
	std::bitset<32> b1(0xaaaa);//00000000000000001010101010101010
	std::bitset<10> b2(0xaaaa);//1010101010
	//0ULL是64个0，~0ULL是64个1
	std::bitset<128> b3(~0ULL);//0-63:1,64-127:0

	//string下标最大的字符初始化bitset最低位（注意使用的位置）
	std::bitset<10> bs1("1100"); //0000001100
	std::string s = "111000";//左为下标最小（1的位置为下标0）
	std::bitset<10> bs2(s,0,2); //0000000011
	std::bitset<10> bs3(s, 2); //0000001000
	std::bitset<10> bs4("22323333",6,'3','2'); //0000110100
1
2
3
4
5
6
7
8
9
10
11
12

3.2操作

• 置位：为1 复位：为0

	std::cout <<"bitset操作：" << std::endl;
	std::bitset<64> b5(0xaaaa);//1010101010101010
	try {
		auto ul = b5.to_ulong();
		std::cout << ul << std::endl;
	}catch (std::overflow_error err) {
		std::cerr << err.what() << std::endl;
	}
1
2
3
4
5
6
7
8

3.3使用

	std::bitset<30> quizB;
	quizB.set(27);  //设置第27位是否通过测验
	status = quizB[27]; //查看27未是否通过测验
	quizB.reset(27);
1
2
3
4

4正则表达式

空，代补

5随机数

5.1随机数生成方法

• 新标准前，采用C库函数rand，生成均匀分布的伪随机整数（0-32767），现在应使用default_random_engine类+分布类对象。
• 新标准，使用头文件#include,库中包含随机数引擎类和随机数分布类，通过引擎类生成的随机数，使用分布类生成指定类型、给定范围内的、服从特定概率分布的随机数。

5.2随机数引擎与分布

• 随机数发生器：分布对象和引擎对象的组合