本文是我重温《C++ Primer 5》第二部分 C++ 标准库时，摘录的一些要点，适合初级程序员食用。

本文结构

• IO 库
  • IO 库类型和头文件
  • IO 库条件状态
  • IO 输出缓冲
  • 文件输入输出
  • string 流
  • 格式化输入输出
  • 流随机访问
• 顺序容器
  • 顺序容器概述
  • 顺序容器选择
  • 容器基本操作
    • 类型别名
    • 构造函数
    • 常用操作
    • 反向容器
    • 迭代器
    • array 容器
  • 顺序容器操作
    • 添加元素
    • 访问元素
    • 删除元素
    • 改变大小
    • 容量管理
    • string 常用操作
    • string 搜索操作
    • string 数值转换
    • 特殊的 forward_list
  • 容器适配器
    • 基本操作
    • stack
    • queue, priority_queue
• 容器泛型算法
  • lambda 表达式
  • 函数适配器 bind
  • 各种迭代器
• 关联容器
  • 关联容器构造
  • pair 类型
  • 关联容器操作
    • 类型别名
    • map 类操作
    • 关联容器常用操作
    • 无序关联容器
• 动态内存
  • new, delete
  • 智能指针

IO 库

IO 库类型和头文件

类型ifstream和istringstream都继承自istream。

类型ofstream和ostringstream都继承自ostream。

所以我们可以像使用cin和cout一样使用文件流和string流对象。

IO 对象无拷贝或赋值

不能将形参或返回类型设置为流类型。

进行 IO 操作的函数通常以引用方式进行传递和返回流。

读写一个 IO 对象会改变其状态，因此传递和返回的引用都不能时const的。

IO 库条件状态

如果达到文件结束位置，eofbit和failbit都会被置位。

一个流一旦发生错误，那么后续的所有 IO 操作都会失败。因此在使用一个流之前必须检查它是否处于良好状态。

确定一个流对象状态的最简单方法是将它当做一个条件来使用：

while(cin >> word)
{
    // do something
    // badbit,failbit,eofbit任一个被置位，则检测流状态的条件会失败
}

将流当做条件使用不等于使用!fail()，因为fail()只检查failbit位和badbit位，而流状态会检查三个错误位。因此，将流当做条件使用与使用good()是等效的。

...
static constexpr _Iostate goodbit = (_Iostate)0x0;
static constexpr _Iostate eofbit = (_Iostate)0x1;
static constexpr _Iostate failbit = (_Iostate)0x2;
static constexpr _Iostate badbit = (_Iostate)0x4;
...
bool __CLR_OR_THIS_CALL good() const
    {	// test if no state bits are set
    return (rdstate() == goodbit);
    }

bool __CLR_OR_THIS_CALL eof() const
    {	// test if eofbit is set in stream state
    return ((int)rdstate() & (int)eofbit);
    }

bool __CLR_OR_THIS_CALL fail() const
    {	// test if badbit or failbit is set in stream state
    return (((int)rdstate()
        & ((int)badbit | (int)failbit)) != 0);
    }

bool __CLR_OR_THIS_CALL bad() const
    {	// test if badbit is set in stream state
    return (((int)rdstate() & (int)badbit) != 0);
    }

IO 输出缓冲

每个输出流都管理一个缓冲区，用来保存程序读写的数据。例如，当你使用如下代码时：

os << "hahah";

文本串可能立即打印出来，也有可能被操作系统保存在缓冲区随后打印。

若程序异常终止，输出缓冲区是不会被刷新的。在log调试的时候，一定要确保所有缓冲区的数据确实已经输出了，不然你会浪费时间在一些你认为没执行但其实已经执行了的代码上面。

缓冲机制可以将程序的多个输出操作组合成单一的系统级写操作，这样可以提升性能。

刷新输出缓冲区

std::cout << "hahah" << std::endl;  // 输出hahah加一个换行，然后刷新缓冲区
std::cout << "hahah" << std::ends;  // 输出hahah加一个空字符，然后刷新缓冲区
std::cout << "hahah" << std::flush; // 输出hahaa不附加任何字符，然后刷新缓冲区

unibuf 操纵符

std::cout << std::unitbuf;   // 所有输出立即刷新，无缓冲
std::cout << std::nounitbuf; // 回归正常输出状态，有缓冲

std::cerr默认是设置unitbuf的，所以log调试时，你可以使用std::cerr进行输出。当然你也可以手动设置一个流为unitbuf的。

输出流关联到另一个流

若一个输出流被关联到另一个流，那么当读写另一个流时，该输出流会被刷新。

std::cin和std::cerr默认都关联到std::cout。

每个流最多同时关联一个流，但输出流可以同时被关联多个流。

关联函数tie有两个重载的版本：

• 不带参数的版本，返回关联的输出流的指针；若没有关联输出流，那么返回空指针。

std::ostream *p = std::cin.tie();
if(p) *p << "hahah\n";

• 带参数的版本，接受一个指向ostream的指针，将自己关联到该ostream，并返回旧的关联输出流。

std::ostream *old_tie = std::cin.tie(nullptr); // 解除关联
if (!std::cin.tie()) std::cout << "std::cin.tie() == nullptr\n";
std::cin.tie(old_tie);
if (std::cin.tie()) std::cout << "std::cin.tie() != nullptr\n";

文件输入输出

头文件<fstream>定义了三个类型

• ifstream: 读取给定文件；
• ofstream: 写入给定文件；
• fstream : 读写给定文件。

除了继承自iostream类型的行为外，fstream还定义了一些自己独有的成员：

可以类比iostream来运用fstream。

文件模式

文件模式用来指出如何使用文件。

ifstream默认使用in模式；ofstream默认使用out模式，而out模式默认指定trunc模式；fstream默认使用in和out模式。

std::ofstream out("file");
std::ofstream out1("file", std::ofstream::out);
std::ofstream out2("file", std::ofstream::out | std::ofstream::app);

string 流

头文件<sstream>也定义了三个类型

• istringstream: 读取给定string；
• ostringstream: 写入给定string；
• stringstream : 读写给定string。

除了继承自iostream类型的行为外，sstream还定义了一些自己独有的成员：

当函数得到整行文本，但却需要处理单个单词时，使用std::istringstream会很方便；

当需要逐步构造输出，最后一起打印时，使用std::ostringstream会比较方便。

格式化输入输出

标准库定义了一组操纵符来改变流的格式状态。当操纵符改变流的格式状态时，通常改变后的状态对所有后续IO都生效。

char ch;
cin >> noskipws;
while(cin >> ch){
	cout << ch;
}
cin >> skips;

float f = 1.243f;
auto dp = cout.precision();
cout << setprecision(12) << f << std::endl;
cout << setprecision(dp);
cout << setw(12) << 1234 << std::endl;
cout << setfill('*') << internal << setw(12) << -1234 << std::endl;
cout << setfill(' ');

流随机访问

fstream inOut("example.txt");
auto beg_mark = inOut.tellg();
inOut.seekg(0,fstream::end);
auto end_mark = inOut.tellg();
inOut.seekg(beg_mark);
//inOut.seekg(0,fstream::beg);
auto length = end_mark - beg_mark;
cout << length << std::endl;

顺序容器

标准库容器分为顺序容器与关联容器。

顺序容器中元素的顺序由其加入容器时的位置决定；关联容器中元素的顺序由其相关联的关键字值决定。

顺序容器概述

现代 C++ 程序推荐使用标准库容器，而不是更原始的数据结构，如内置数组。

顺序容器选择

通常，使用vector是最好的选择，除非你有很好的理由选择其他容器。

选择容器的基本原则：

• 除非你有很好的理由选择其他容器，否则应该使用vector；
• 如果你的程序有很多小元素，且空间的额外开销很重要，不要使用list或forward_list；
• 如果程序要求随机访问元素，应使用vector或deque；
• 如果程序要求在容器的中间插入或删除元素，应使用list或forward_list；
• 如果程序要求在头尾位置插入或删除元素，但不会在中间位置插入或删除，那么使用deque；
• 如果程序只有在读取输入时才需要在容器中间位置插入元素，随后需要随机访问，
  • 确定是否真的需要在容器中间插入元素，排序之类的可以使用sort重排；
  • 如果必须在中间插入元素，考虑在输入阶段使用list，输入完成之后将其拷贝到vector中；
• 如果程序既要求随机访问又要求在容器中间插入，那么根据占主导地位的操作选择容器。

容器基本操作

类型别名

类型别名在泛型编程中非常有用。

构造函数

常用操作

反向容器

对一个反向迭代器执行++操作，会得到上一个元素。

迭代器

forward_list迭代器不支持递减运算符。

当不需要写访问时，使用c(r)begin和c(r)end。

除了为每个容器定义的迭代器之外，标准库在头文件iterator中还定义了额外几种迭代器。

#include <iostream>
#include <iterator>
#include <vector>
 
int main() 
{
    std::vector<int> v{ 3, 1, 4 };
    std::cout << "distance(first, last) = "
              << std::distance(v.begin(), v.end()) << '\n'  // C++ 17
              << "distance(last, first) = "
              << std::distance(v.end(), v.begin()) << '\n';

	std::vector<int> v{ 3, 1, 4 };
    auto vi = v.begin();
    std::advance(vi, 2);                                    // C++ 17
    std::cout << *vi << '\n';
}

array 容器

定义一个array时，除了指定元素类型，还要指定容器大小:

std::array<int, 42> arr;

array不初始化时使用默认初始化；列表初始化时，未被初始化得元素将使用值初始化，自定义类必须包含一个默认构造函数：

std::array<int, 42> arr0;                 // 默认初始化
std::array<int, 42> arr1{1,2,3,4,5};      
std::array<int, 42> arr2 = {2,3,4,5,6};

array可以进行拷贝和赋值操作：

std::array<int, 42> arr0{2,3,4,5,6};
// 拷贝赋值时容器类型、元素类型、容器大小都必须相同
std::array<int, 42> arr1(arr0);
std::array<int, 42> arr2 = arr0;
arr2 = arr1;

顺序容器操作

添加元素

array不支持添加元素。

forward_list不支持push_back和emplace_back；forward_list有自己专有版本的insert和emplace。

vector和string不支持push_front和emplace_front。

使用一个对象来初始化容器或将一个对象插入到容器中时，放入容器中的元素是对象值得一个拷贝，而不是对象本身。

emplace,emplace_back和emplace_front是C++11新引入的成员，它们在容器中直接构造元素，传递给emplace函数的参数必须与元素类型的构造函数相匹配。无参数时，使用默认构造函数。

访问元素

auto b1 = c.back();  // b1是c中最后一个元素的拷贝
auto &b2 = c.back(); // b2是c中最后一个元素的引用

删除元素

array不支持删除元素。

forward_list有特殊版本的erase；forward_list不支持pop_back。

vector和string不支持pop_front。

删除元素前，必须确保它们是存在的。

改变大小

resize并不改变容器capacity()的大小。

原先得到的迭代器在容器操作后可能造成迭代器失效，使用失效的迭代器会造成严重的运行错误，建议在每次容器操作之后都更新一下指向相应容器的迭代器。

容量管理

由于vector和string的元素是连续存储的，向它们添加元素时：

• 容器必须分配新的内存空间来保存已有元素和新元素；
• 将已有元素从旧的位置移动到新空间；
• 然后添加新元素，释放旧存储空间。

如果每次添加都执行一次分配和释放操作，会严重降低性能。

标准库采用可以减少容器重新分配次数的策略：

• 不得不获取新的内存空间时，vector和string会分配比新的空间需求更大的内存空间；
• 容器预留这些空间作为备用，用以保存更多的新元素;
• 采用这种策略后，vector的扩张操作比list和deque更快。

string 常用操作

args形式

string 搜索操作

args形式

string 数值转换

如果string不能转换为一个数值，这些函数抛出一个invalid_argument异常。

如果转换后的数值无法用任何类型表示，则返回一个out_of_range异常。

能够进行数值转换的string格式：

• string参数中第一个非空白字符必须是符号+或-或数字；
• 它可以以0x或0X开头表示十六进制数；
• 对于要转换成浮点数的函数，string参数也可以以小数点(.)开头，并可以包含e或E来表示指数部分；
• 对于要转换成整型值的函数，根据基数不同，string参数可以包含字母字符，对应大于9的数。

特殊的`forward_list`

在一个forward_list中添加或删除元素的操作是通过改变给定元素之后的元素来完成的。

容器适配器

标准库定义了三个顺序容器适配器，这些适配器不能用于array和forward_list

• stack
• queue: 不能用于vector
• priority_queue: 不能用于list

基本操作

stack

stack定义于头文件<stack>，默认基于deque实现，采用先进后出策略

queue, priority_queue

queue, priority_queue定义于头文件<queue>，采用先进先出策略

• queue默认基于deque实现；
• priority_queue默认基于vector实现，使用std::less确定相对优先级，即最大的排在最前面。

struct ListNode {
	int val;
	ListNode *next;
	ListNode(int x) : val(x), next(NULL) {}
};
priority_queue<ListNode *, vector<ListNode *>, function<bool(ListNode *, ListNode *)>>
	pQueue([](ListNode *a, ListNode *b) {return a->val > b->val; });

容器泛型算法

大多数算法定义于头文件<algorithm>中。

list和forward_list有专门的sort, merge, remove, reverse和unique算法，并且定义了独有的splice成员，用于拼接。

很多算法都有重载，以及_if, _copy, _n, _not等后缀组合的版本，下面列出一些常用算法：

lambda 表达式

lambda 表达式表示一个可调用的代码单元，可以简单的理解为一个未命名的内联函数。对于那种只在一两个地方使用的简单操作，lambda 表达式是最有用的。

一个 lambda 表达式具有一个返回类型、一个参数列表和一个函数体:

[capture list](parameter list) -> return type { function body }

• capture list 表示该lambda表达式能够使用的非静态局部变量的列表，为空时代表该lambda表达式不使用任何非静态局部变量；
• 变量的捕获可以是值或引用。为值时，对相应值的改变不会影响到原值；为引用时，必须确保该lambda在执行时，引用变量是存在的；
• 当捕获列表为[=]时，代表lambda函数体中使用的所有非静态局部变量都采用值捕获；
• 当捕获列表为[&]时，代表lambda函数体中使用的所有非静态局部变量都采用引用捕获；
• 当捕获列表为[=, identifier_list]时，代表lambda函数体中除identifier_list列表中的引用捕获变量外，其它使用的所有非静态局部变量都采用值捕获；
• 当捕获列表为[&, identifier_list]时，代表lambda函数体中除identifier_list列表中的值捕获变量外，其它使用的所有非静态局部变量都采用引用捕获；
• 一个lambda只有在其捕获列表中捕获一个它所在函数中的非静态局部变量后，才能在函数体中使用该变量；
• 一个lambda可以直接使用定义在它所在函数中的静态局部变量和定义在它所在函数之外的可用的变量；
• parameter list 不能包含默认参数；
• lambda 必须使用尾置返回类型；
• lambda 表达式可以忽略参数列表及括号和返回类型，但必须包含capture list 和 function body。
• 忽略参数列表及括号代表不接受参数；
• 忽略返回类型，如果lambda表达式包含任何单一return语句之外的内容，则返回void；否则从返回表达式的类型推断出返回类型；

void example(std::ostream &os)
{
	std::vector<int> vec{ 1,2,3,3,2,1 };
	int num = 2;
	transform(cbegin(vec), cend(vec), begin(vec), 
		[&os, num](const int &i) -> int 
	{
		os << i << std::ends;
		return i < num ? i : num; 
	}
	);
	os << std::endl;
	for_each(cbegin(vec), cend(vec),
		[](const int &i)
	{
		std::cout << i << std::ends;
	}
	);
}

函数适配器 bind

C++11 在<functional>头文件中定义了一个名为bind的标准库函数，它接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表。

auto newCallable = bind(callable, arg_list);

• newCallable 本身是一个可调用对象；
• arg_list 是一个逗号分隔的参数列表，对应于 callable 的参数；
• 当我们调用 newCallable 时，newCallable 会调用 callable，并按顺序传递给它arg_list 中的参数；
• arg_list 中如果需要引用传递，须使用std::ref或std::cref函数，c代表const；
• arg_list 中的参数可能包含形如 _n 的名字，其中n是一个整数，代表在生成的可调用对象中参数的位置，例如_2代表第二个参数；
• arg_list 中 _n 的最大值为生成的可调用对象参数的总个数；

# include <iostream>
# include <string>
# include <vector>
# include <algorithm>
# include <functional>

bool isShorter(const std::string &s1, const std::string &s2);
void print(std::ostream &os, const std::string &s);
void print(const int *begin, const int *end);

int main()
{
	using namespace std;

	vector<string> svec{ "jskda","asda","dkasdka","iqheqen","qyeiqk" };
	sort(begin(svec), end(svec), isShorter);
	// 与上面效果一样
	sort(begin(svec), end(svec),
		[](const std::string &s1, const std::string &s2)
	{
		return s1.size() < s2.size();
	}
	);

	// 使用 _1, _2
	using namespace std::placeholders;

	// 利用bind重排参数顺序，反向排序
	sort(begin(svec), end(svec), bind(isShorter,_2,_1));

	for_each(cbegin(svec), cend(svec), 
		[](const std::string &s)
	{
		cout << s << std::endl;
	}
	);
	// 使用bind将cout引用绑定到print第一个参数，生成一个只接受一个参数的可调用对象
	// 如果bind的函数有重载，须使用 static_cast 指定类型，print可以添加取地址符号&
	for_each(cbegin(svec), cend(svec), 
		bind(static_cast<void(*)(std::ostream &, const std::string &)>(print), ref(cout), _1));

	getchar();
	return 0;
}

bool isShorter(const std::string &s1, const std::string &s2)
{
	return s1.size() < s2.size();
}

void print(std::ostream &os, const std::string &s)
{
	os << s << std::endl;
}

void print(const int *begin, const int *end)
{
	while (begin != end) std::cout << *begin++ << std::endl;
}

各种迭代器

std::istream_iterator<int> in_iter(std::cin), eof;
// 读取输入，并保存到一个vector
std::vector<int> vec(in_iter, eof);
// 读取输入，并求和
// auto sum = std::accumulate(in_iter, eof, 0);
// std::ostream_iterator<T> out(os, d)
// 将类型为T的值写到os，每个值后面输出一个d，d指向一个空字符结尾的字符数组
std::ostream_iterator<int> out(std::cout, " ");
copy(std::cbegin(vec), std::cend(vec), out);
std::cout << std::endl;

关联容器

关联容器中的元素是按关键字来保存和访问的。map类的元素类型为pair;

对于有序容器map,set,multimap和multiset，关键字类型必须定义元素比较的方法。

关联容器构造

// 空容器
map<type1, type2> map_name1;
// 列表初始化
map<type1, type2> map_name2 = { {key1, value1}, {key2, value2}, ... };
// 指定func_comp为map_name3关键字的排序算法
map<type1, type2, decltype(func_comp) *> map_name3(func_comp);
// 空容器
set<type> set_name1;
// 列表初始化
set<type> set_name2 = { key1, key2, ... };
// set_name2包含来自c的不重复元素，且从小到大进行排列
set<type> set_name3(c.cbegin(), c.cend()); 
// 指定func_comp为set_name4关键字的排序算法
set<type, decltype(func_comp)*> set_name4(func_comp);

pair 类型

pair 定义在头文件<utility>中，保存两个数据成员。

关联容器操作

类型别名

关键字不能被更改。

map 类操作

向map添加元素：

word_count.insert({word, 1});
word_count.insert(make_pair(word, 1));
word_count.insert(pair<string, size_t>(word, 1));
word_count.insert(map<string, size_t>::value_type(word, 1));

map类的下标操作：

• 不能对multimap进行下标操作，因为一个关键字可能对应多个值；
• 对map进行下标操作时，如果关键字没有在map中，那么会创建一个元素插入到map中，并对关联值进行值初始化；
• 不能对const的map进行下标操作，因为下标操作可能插入一个新元素。

关联容器常用操作

无序关联容器

C++11 定义了4个无序关联容器: unordered_map,unordered_set,unordered_multimap和unordered_multiset。这些容器不使用比较运算符组织元素，而是使用哈希函数(将给定类型的值映射到整形size_t值的函数)和关键字的==运算符。

可以直接定义关键字为内置类型、string或智能指针类型的无序容器；对于自定义类型，需要提供自定义的hash模板和==运算符。

无序关联容器可以使用find,insert等操作，理论上哈希技术会获得更好的平均性能。

无论是有序关联容器，还是无序关联容器，具有相同关键字的元素都是相邻存储的。

动态内存

动态分配的对象的生存期与它们在哪里创建无关，只有当其被显式释放时，这些对象才会被销毁。

静态内存用来保存static对象和外部变量，栈内存用来保存函数内的非static对象。动态分配使用栈内存。

new, delete

new: bad_alloc和nothrow定义于头文件<new>中。

type *name = new type;                  // 默认初始化，失败抛出std::bad_alloc
type *name = new type();                // 值初始化
const type *name = new const type(val); // const对象必须初始化，除非有默认构造函数
type *name = new (nothrow) type;        // 失败返回nullptr
// 动态数组，非数组类型
// 不能对动态数组使用begin或end
// size为0时，返回一个合法的非空指针，但不能解引用
type *name = new type[size];
type *name = new type[size]();
type *name = new type[size]{ val0, val1, ... }; // 剩余值进行值初始化
const type *name = new const type[size](val); 
type *name = new (nothrow) type[size];        

delete:

• 传递给delete的指针必须指向动态分配的内存，或是一个空指针；
• 对同一块内存多次释放，可能会破坏内存空间；
• delete之后，指针仍然指向已经释放的动态内存的地址；
• 建议delete之后，赋值为nullptr；

int i, *pi1 = &i, *pi2 = nullptr;
double *pd1 = new double(33), *pd2 = pd1;
const int *pci = new const int(123);
delete i;      // 错误
delete pi1;    // 未定义
delete pi2;    // 可以
delete pd1;    // 正确
delete pd2;    // 未定义，已被释放
delete pci;    // 正确
// 释放动态数组
auto *ip = new int[10]();
delete []ip;

智能指针

智能指针会自动释放(默认使用delete)所指向的对象：

• shared_ptr允许多个指针指向同一个对象；
• unique_ptr独占所指向的对象；
• weak_ptr是一种弱引用，指向shared_ptr所管理的对象；
• 它们都在头文件<memory>中。

shared_ptr自动释放的原理：一旦使用shared_ptr管理指针，就不应该用内置指针来访问shared_ptr所指向的内存。

• 当一个shared_ptr被用于初始化另一个shared_ptr，或将它作为参数传递给一个函数以及作为函数的返回值时，其关联的计数器递增；
• 当一个shared_ptr被赋新值或是其被销毁，其关联的计数器会递减；
• 当一个shared_ptr所关联的计数器变为0时，就会自动释放其保存的指针。

关于unique_ptr:

• 某个时刻只能有一个unique_ptr指向给定的对象；
• 当unique_ptr被销毁时，其所指向的对象也被销毁；
• 定义一个unique_ptr需要将其绑定到一个new返回的指针上，且必须直接初始化；
• unique_ptr不支持拷贝和赋值；
• 可以拷贝或赋值一个即将被销毁的unique_ptr。

关于weak_ptr:

• 不控制所指向对象生存期的智能指针；
• 指向由一个shared_ptr管理的对象；
• 将一个weak_ptr绑定到一个shared_ptr不会改变shared_ptr的引用计数；
• 不能使用weak_ptr直接访问对象，必须调用lock。

unique_ptr<int> p1(new int(10));     // 初始化
unique_ptr<int> p2(p1.release());    // p1的所有权转移给p2，p1置为空
unique_ptr<int> p3(new int(20)); 
p2.reset(p3.release());              // 释放p2，将p3的所有权转移给p2
unique_ptr<int[]> p4(new int[10]()); // 动态数组
p4[1] = 123;
shared_ptr<int> sp(new int[10](), [](int *p){ delete []p; });
*(sp.get() + 1) = 123;               // shared_ptr未定义下标运算符

• Previous
  C++ 释疑（一）
• Next
  C++ 释疑（三）