IO库与STL.

IO库

• istream：输入流类型，提供输入操作。
• ostream：输出流类型，提供输出操作
• cin：一个istream对象，从标准输入读取数据。
• cout：一个ostream对象，向标准输出写入数据。
• cerr：一个ostream对象，向标准错误写入消息。
• >>运算符：用来从一个istream对象中读取输入数据。
• <<运算符：用来向一个ostream对象中写入输出数据。
• getline函数：从一个给定的istream对象中读取一行数据，存入到一个给定的string对象中。

IO类

• iostream头文件：从标准流中读写数据，istream, ostream, iostream等。
• fstream头文件：从文件中读写数据，ifstream, ofstream, fstream等。
• sstream头文件：从字符串中读写数据，istringstream, ostringstream, stringstream等。

IO对象无拷贝或赋值

• 1.IO对象不能存在容器里.
• 2.形参和返回类型也不能是流类型。
• 3.形参和返回类型一般是流的引用。
• 4.读写一个IO对象会改变其状态，因此传递和返回的引用不能是const的。

条件状态

上表中，strm是一种IO类型，（如istream）， s是一个流对象。

管理输出缓冲

每个输出流都管理一个缓冲区，执行输出的代码，文本串可能立即打印出来，也可能被操作系统保存在缓冲区内，随后再打印。

刷新缓冲区，可以使用如下IO操纵符：

• endl：输出一个换行符并刷新缓冲区。
• flush：刷新流，单不添加任何字符。
• ends：在缓冲区插入空字符null，然后刷新。
• unitbuf：告诉流接下来每次操作之后都要进行一次flush操作。
• nounitbuf：回到正常的缓冲方式。

1

cout << unitbuf;    //所有输出操作后都会立即刷新缓冲区。

2

//... 任何输出操作都立即刷新,无缓冲。

3

cout << nounitbuf;  //回到正常的缓冲方式。

文件输入输出

• ifstream从一个给定文件读取数据。
• ofstream向一个给定文件写入数据。
• fstream可以读写给定文件。

文件流：需要读写文件时，必须定义自己的文件流对象，并绑定在需要的文件上。

fstream特有的操作

当一个fstream对象被销毁时,close会自动被调用。

文件模式

默认情况下,打开一个ofstream时,文件内容会被丢弃。保留被ofstream打开的文件中已有数据的唯一方法是显示指定app或in模式ofstream app("file", ofstream::out | ofstream::app)。

string流

头文件sstream定义了三个类型来支持内存IO：

• istringstream从string读取数据。
• ostringstream向string写入数据。
• stringstream可以读写给定string。

stringstream特有的操作

顺序容器

迭代器

迭代器范围：begin到end，即第一个元素到最后一个元素的后面一个位置(one past the last element)。
左闭合区间：$ [begin, end) $

左闭合范围蕴含的编程设定：

• 如果begin和end相等，则范围为空。
• 如果二者不等，则范围至少包含一个元素，且begin指向该范围中的第一个元素。
• 可以对begin递增若干次，使得begin == end。

获取迭代器

• 以c开头的版本是C++11新标准引入的
• 当不需要写访问时，应该使用cbegin和cend。
• 不支持forward_list

在向容器添加元素后：

• 如果容器是vector或string，且存储空间被重新分配，则指向容器的迭代器、指针、引用都会失效。
• 对于deque，插入到除首尾位置之外的任何位置都会导致指向容器的迭代器、指针、引用失效。如果在首尾位置添加元素，迭代器会失效，但指向存在元素的引用和指针不会失效。
• 对于list和forward_list，指向容器的迭代器、指针和引用依然有效。

在从一个容器中删除元素后：

• 对于list和forward_list，指向容器其他位置的迭代器、引用和指针仍然有效。
• 对于deque，如果在首尾之外的任何位置删除元素，那么指向被删除元素外其他元素的迭代器、指针、引用都会失效；如果是删除deque的尾元素，则尾后迭代器会失效，但其他不受影响；如果删除的是deque的头元素，这些也不会受影响。
• 对于vector和string，指向被删元素之前的迭代器、引用、指针仍然有效。
• 注意：当我们删除元素时，尾后迭代器总是会失效。
• 注意：使用失效的迭代器、指针、引用是严重的运行时错误！
• 建议：将要求迭代器必须保持有效的程序片段最小化。
• 建议：不要保存end返回的迭代器。

类型

容器定义和初始化

• 只有顺序容器的构造函数才接受大小参数，关联容器并不支持。
• array具有固定大小。
• 和其他容器不同，默认构造的array是非空的。
• 直接复制：将一个容器复制给另一个容器时，类型必须匹配：容器类型和元素类型都必须相同。
• 使用迭代器复制：不要求容器类型相同，容器内的元素类型也可以不同。

赋值和swap

• 使用非成员版本的swap是一个好习惯(非成员版本的swap在泛型编程中非常重要)。
• assign操作不适用于关联容器和array,仅顺序容器有效。
• 除array外,swap不对任何元素进行拷贝,删除或插入操作。

大小

顺序容器添加元素

• 向vector,string或deque插入元素会使所有指向容器的迭代器,引用和指针失效。
• 因为这些操作会改变大小，因此不适用于array。
• forward_list有自己专有版本的insert和emplace。
• forward_list不支持push_back和emplace_back。
• 当我们用一个对象去初始化容器或者将对象插入到容器时，实际上放入的是对象的拷贝。
• emplace开头的函数是新标准引入的，这些操作是构造而不是拷贝元素。
• 传递给emplace的参数必须和元素类型的构造函数相匹配。

访问元素

• 访问成员函数返回的是引用。
• at和下标操作只适用于string、vector、deque、array。
• back不适用于forward_list。
• 如果希望下标是合法的，可以使用at函数。

删除元素

• 会改变容器大小，不适用于array。
• forward_list有特殊版本的erase
• forward_list不支持pop_back
• vector和string不支持pop_front

特殊的forwad_list操作

• 链表在删除元素时需要修改前置节点的内容，双向链表会前驱的指针，但是单向链表没有保存，因此需要增加获取前置节点的方法。
• forward_list定义了before_begin，即首前（off-the-begining）迭代器，允许我们再在首元素之前添加或删除元素。

改变容器大小

vector分配原理

vector和string在内存中是连续保存的，如果原先分配的内存位置已经使用完，则需要重新分配新空间，将已有元素从就位置移动到新空间中，然后添加新元素。

• shrink_to_fit只适用于vector、string和deque。
• capacity和reverse只适用于vector和string。

额外的string操作

构造string的其他方法

• n,len,pos2都是无符号值。

substr操作

改变string的其他方法

string搜索操作

• string类提供了6个不同的搜索函数，每个函数都有4个重载版本。
• 每个搜索操作都返回一个string::size_type值，表示匹配发生位置的下标。如果搜索失败则返回一个名为string::npos的static成员（类型是string::size_type，初始化值是-1，也就是string最大的可能大小）。

args必须是一下的形式之一：

s.compare的几种参数形式

逻辑类似于C标准库的strcmp函数，根据s是等于、大于还是小于参数指定的字符串，s.compare返回0、正数或负数。

string和数值转换

容器适配器（adapter）

• 适配器是使一事物的行为类似于另一事物的行为的一种机制，例如stack可以使任何一种顺序容器以栈的方式工作。
• 初始化 deque<int> deq; stack<int> stk(deq); 从deq拷贝元素到stk。
• 创建适配器时，指定一个顺序容器，可以覆盖默认的基础容器： stack<string, vector<string> > str_stk;。

适配器的通用操作和类型

stack

• 定义在stack头文件中。
• stack默认基于deque实现，也可以在list或vector之上实现。

queue和priority_queue

• 定义在queue头文件中。
• queue默认基于deque实现，priority_queue默认基于vector实现。
• queue可以在list或vector之上实现，priority_queue也可以用deque实现。

泛型算法

因为它们实现共同的操作，所以称之为“算法”；而“泛型”、指的是它们可以操作在多种容器类型上。

泛型算法本身不执行容器操作，只是单独依赖迭代器和迭代器操作实现。

1

#include <algorithm>

2

#include <numeric> //算数相关

大多数算法是通过遍历两个迭代器标记的一段元素来实现其功能。

必要的编程假定：算法永远不会改变底层容器的大小。算法可能改变容器中保存的元素的值，也可能在容器内移动元素，但不能直接添加或者删除元素。

1

vector<int>::const_iterator result = find(vec.begin(), vec.end(), search_value);

输入：两个标记范围的迭代器和目标查找值。
返回：如果找到，返回对应的迭代器，否则返回第二个参数，即标记结尾的迭代器。

只读算法

• 只读取范围中的元素，不改变元素。
• 如 find和 accumulate（在numeric中定义，求和）。
• find_first_of，输入：两对迭代器标记两段范围，在第一段中找第二段中任意元素，返回第一个匹配的元素，找不到返回第一段的end迭代器。
• 通常最好使用cbegin和cend。
• equal：确定两个序列是否保存相同的值。

写容器元素的算法

一些算法将新值赋予序列中的元素。算法不检查写操作(假定目的位置足够大)。

1

fill(vec.begin(), vec.end(), 0);    //将每个元素重置为0

2

fill_n(vec.begin(), 10, 0);

插入迭代器back_inserter,接受一个指向容器的引用,返回一个与该容器绑定的插入迭代器。通过此迭代器赋值时,赋值运算符会调用push_back将一个具有给定值的元素添加到容器中。

1

#include <iterator>

2

3

vector<int> vec;

4

auto it = back_inserter(vec);

5

*it = 42;

6

fill_n(back_inserter(vec), 10, 0);

• 拷贝算法copy：
• 输入：前两个参数指定输入范围，第三个指向目标序列。
• copy (ilst.begin(), ilst.end(), back_inserter(ivec));
• copy时必须保证目标目的序列至少要包含与输入序列一样多的元素。

重排容器元素的算法

排序算法sort,接受两个迭代器，表示要排序的元素范围。

消除重复unique：

• 之前要先调用sort
• 返回的迭代器指向最后一个不重复元素之后的位置。
• 顺序会变，重复的元素被“删除”。
• 并没有真正删除，真正删除必须使用容器操作。

1

void elimDups(vector<string> &words)

2

{

3

    sort(words.begin(), words.end());

4

    auto end_unique = unique(words.begin(), words.end());

5

    words.erase(end_unique, words.end());

6

}

定制操作

向算法传递函数：

谓词(predicate)是一个可调用的表达式，返回结果是一个能用作条件的值。一元谓词接受一个参数,二元谓词接受两个参数。

1

bool isShorter(const string &s1, const string &s2)

2

{

3

    return s1.size() < s2.size();

4

}

5

stable_sort(words.begin(), words.end(), isShorter);

lambda表达式

lambda表达式表示一个可调用的代码单元，可以理解成是一个未命名的内联函数。

1

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

• capture list捕获列表是一个lambda所在函数定义的局部变量的列表(通常为空),不可忽略。
• return type是返回类型,lambda必须使用尾置返回形式,可忽略。
• parameter是参数列表,可忽略。
• function body是函数体,不可忽略。
• 可以忽略参数列表和返回类型,但必须包含捕获列表和函数体。

1

auto f = [] {return 42;}

2

cout << f() <<endl;

lambda不能有默认参数,实参与形参类型必须匹配且数目相等。

lambda只有在其捕获列表中捕获一个它所在函数中的局部变量,才能在lambda函数体中使用该变量。

捕获列表只用于局部非static变量,lambda可以直接使用局部static变量和在它所在函数之外声明的名字。

1

void biggies(vector<string> &words,

2

                vector<string>::size_type sz)

3

{

4

    elimDups(words);

5

    stable_sort(words.begin(), words.end(),

6

            [](const string &a, const string &b)

7

                { return a.size() < b.size(); });

8

9

    auto wc = find_if(words.begin(), words.end(),

10

            [sz](const string &a)

11

                { return a.size() >= sz; });

12

13

    auto count = words.end() - wc;

14

    cout << count << " " << make_plural(count, "word", "s")

15

        << " of length " << sz << " or longer" << endl;

16

17

    for_each(wc, words.end(),

18

            [](const string &s) {const << s << " ";});

19

    cout << endl;

20

}

lambda捕获和返回

定义lambda时,编译器会生成一个与lambda对应的新的(未命名的)类类型。当向一个函数传递一个lambda时,同时定义了一个新类型和该类型的一个对象:传递的参数就是此编译器生成的类类型的未命名对象。

默认情况下，从lambda生成的类都包含一个对应该lambda所捕获的变量的数据成员，在lambda对象创建时被初始化。

值捕获：被捕获的变量是可以拷贝，且被捕获的变量是在lambda创建时拷贝,而不是调用时拷贝。

1

void fcn1()

2

{

3

    size_t v1 = 42; //局部变量

4

    auto f = [v1] { return v1; };

5

    v1 = 0;

6

    auto j = f();   //j为42,f保存了我们创建它时v1的拷贝

7

}

引用捕获：必须保证在lambda执行时，变量是存在的，当函数返回一个lambda,此lambda也不能包含引用捕获。

1

void fcn2()

2

{

3

    size_t v1 = 42;

4

    auto f2 = [&v1] {return v1;};

5

    v1 = 0;

6

    auto j = f2(); // j为0

7

}

尽量减少捕获的数据量，尽可能避免捕获指针或引用。

隐式捕获：让编译器推断捕获列表，在捕获列表中写一个&(引用捕获方式)或=(值捕获方式), 也可以混合使用隐式捕获和显示捕获。

1

void biggies(vector<string> &words, vector<string>::size_type sz,

2

        ostream &os = cout, char c = ' ')

3

{

4

    for_each(words.begin(), words.end(),

5

        [&, c](const string &s) { os << s << c; });

6

7

    for_each(words.begin(), words.end(),

8

        [=, &os](const string &s) { os << s << c; });

9

}

当混合使用隐式和显示捕获时,捕获列表中的第一个元素必须是&或=。此符号指定了默认捕获方式。

lambda捕获列表：

默认情况下,对于一个值被拷贝的变量,lambda不会改变其值。如果我们希望能改变一个被捕获的变量的值,就必须在参数列表首加上关键字mutable。因此,可变lambda能省略参数列表。

1

void fcn3()

2

{

3

    size_t v1 = 42;

4

    auto f = [v1] () mutable { return ++v1; };

5

    v1 = 0;

6

    auto j = f(); //j==43

7

}

默认情况下,如果一个lambda体包含return之外的任何语句,则编译器假定此lambda返回void。被推断为void的lambda不能返回值。当我们需要为一个lambda定义返回类型时,必须使用尾置返回类型。

1

transform(v1.begin(), v1.end(), v1.begin(),

2

        [](int i) ->int { if(i < 0) return -i; else return i; });

参数绑定

lambda表达式更适合在一两个地方使用的简单操作。如果是很多地方使用相同的操作，还是需要定义函数。

标准库bind函数：定义在头文件functional中，可以看做为一个通用的函数适配器。接受一个可调用对象,生成一个新的可调用对象来”适应”原对象的参数列表。

1

auto newCallable = bind(callable, arg_list);

调用newCallable的时候，newCallable会调用callable并传递给它arg_list中的参数。arg_list中的参数可能包含形如_n的名字,其中n是一个整数,这些参数表示占位符的意思, 表示newCallable的参数,占据了传递给newCallable的参数的”位置”。数值n表示生成的可调用对象中参数的位置: _1为newCallable的第一个参数, _2为第二个参数,以此类推。

名字_n定义在placeholders的命名空间中。

1

using namespace std::placeholders;

1

auto g = bind(f, a, b, _2, c, _1);

2

//g(_1, _2) = f(a, b, _2, c, _1)

非占位符的参数要使用引用传参，必须使用标准库ref函数或者cref(const引用类)函数。

1

for_each(words.begin(), words.end(),

2

        bind(print, ref(os), _1, ' '));

再探迭代器

插入迭代器

插入器是一种迭代器适配器，接受一个容器，生成一个迭代器，能实现向给定容器添加元素。

• back_inserter创建一个使用push_back的迭代器。
• front_inserter创建一个使用push_front的迭代器。
• inserter创建一个使用insert的迭代器。接受第二个参数，即一个指向给定容器的迭代器，元素会被查到迭代器所指向的元素之前。

插入迭代器操作

iostream迭代器

迭代器可与输入或输出流绑定在一起，用于迭代遍历所关联的 IO 流。通过使用流迭代器，我们可以用泛型算法从流对象中读取数据以及向其写入数据。

istream_iterator的操作

ostream_iterator的操作：

反向迭代器

反向迭代器就是在容器中从尾元素向首元素反向移动的迭代器。

对于反向迭代器，递增和递减的操作含义会颠倒。

实现向后遍历，配合rbegin和rend。

泛型算法结构

5类迭代器

算法的形参模式

1

alg(beg, end, other args);

2

alg(beg, end, dest, other args);

3

alg(beg, end, beg2, other args);

4

alg(beg, end, beg2, end2, other args);

其中，alg是算法名称，beg和end表示算法所操作的输入范围。dest、beg2、end2都是迭代器参数，是否使用要依赖于执行的操作。

算法命名规范

• 一些算法使用重载形式传递一个谓词。
• 接受一个元素值的算法通常有一个不同名的版本：加_if，接受一个谓词代替元素值。
• 区分拷贝元素的版本和不拷贝的版本：拷贝版本通常加_copy。

特定容器算法

• 对于list和forward_list，优先使用成员函数版本的算法而不是通用算法。

list和forward_list成员函数版本的算法

上面的操作都返回void

list和forward_list的splice**成员函数版本的参数：

使用lst.splice(args)或flst.splice_after(args)

关联容器

关联容器和顺序容器的不同：关联容器中的元素时按照关键字来保存和访问的。

关联容器支持通过关键字来高效地查找和读取元素，基本的关联容器类型是 map和 set。

关联容器类型：

关联容器概述

定义关联容器

需要指定元素类型。

列表初始化：

关键字类型的要求

对于有序容器，关键字类型必须定义元素比较的方法。默认是<。

如果想传递一个比较的函数，可以这样定义：multiset<Sales_data, decltype(compareIsbn)*> bookstore(compareIsbn);

pair

在utility头文件中定义。

一个pair保存两个数据成员，两个类型不要求一样。

pair的操作：

关联容器操作

关联容器额外的类型别名

关联容器迭代器

解引用一个关联容器迭代器时，会得到一个类型为容器的value_type的值的引用。

set的迭代器是const的。

遍历关联容器：使用begin和end，遍历map、multimap、set、multiset时，迭代器按关键字升序遍历元素。

添加元素

关联容器insert操作

向map添加元素：

1

word_count.insert({word, 1});

2

word_count.insert(make_pair(word, 1));

3

word_count.insert(pair<string, size_t>(word, 1));

4

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

删除元素

从关联容器中删除元素

下标操作

map和unordered_map的下标操作

查找元素

在一个关联容器中查找元素

lower_bound和upper_bound不适用于无序容器。

下标和at操作只适用于非const的map和unordered_map。

无序容器

有序容器使用比较运算符来组织元素；无序容器使用哈希函数和关键字类型的==运算符。

理论上哈希技术可以获得更好的性能。

无序容器在存储上组织为一组桶(bucket)，每个桶保存零个或多个元素。无序容器使用一个哈希函数将元素映射到桶。

无序容器管理操作

动态内存与智能指针

对象的生命周期：

• 全局对象在程序启动时分配，结束时销毁。
• 局部对象在进入程序块时创建，离开块时销毁。
• 局部static对象在第一次使用前分配，在程序结束时销毁。
• 动态分配对象：只能显式地被释放。

对象的内存位置：

• 静态内存用来保存局部static对象、类static对象、定义在任何函数之外的变量。
• 栈内存用来保存定义在函数内的非static对象。
• 堆内存，又称自由空间，用来存储动态分配的对象。

动态内存与智能指针

动态内存管理：

• new：在动态内存中为对象分配空间并返回一个指向该对象的指针。
• delete：接受一个动态对象的指针，销毁该对象，并释放与之关联的内存。

智能指针：

• 管理动态对象。
• 行为类似常规指针。
• 负责自动释放所指向的对象。
• 智能指针也是模板。

shared_ptr类

shared_ptr和unique_ptr都支持的操作

shared_ptr独有的操作

使用动态内存的三种原因：

• 程序不知道自己需要使用多少对象（比如容器类）。
• 程序不知道所需要对象的准确类型。
• 程序需要在多个对象间共享数据。

直接管理内存

用new动态分配和初始化对象。

• new无法为分配的对象命名（因为自由空间分配的内存是无名的），因此是返回一个指向该对象的指针。
• int *pi = new int(123);
• 一旦内存耗尽，会抛出类型是bad_alloc的异常。

用delete将动态内存归还给系统。

• 接受一个指针，指向要释放的对象。
• delete后的指针称为空悬指针（dangling pointer）。

使用new和delete管理动态内存存在三个常见问题：

• 1.忘记delete内存。
• 2.使用已经释放掉的对象。
• 3.同一块内存释放两次。

坚持只使用智能指针可以避免上述所有问题。

shared_ptr和new结合使用

定义和改变shared_ptr的其他方法

智能指针和异常

如果使用智能指针，即使程序块由于异常过早结束，智能指针类也能确保在内存不需要的时候将其释放。

智能指针陷阱：

• 不用相同的内置指针初始化（或reset）多个智能指针
• 不delete get()返回的指针。
• 如果你使用get()返回的指针，记得当最后一个对应的智能指针销毁后，你的指针就无效了。
• 如果你使用智能指针管理的资源不是new分配的内存，记住传递给它一个删除器。

unique_ptr

某一个时刻只能有一个unique_ptr指向一个给定的对象。

不支持拷贝或者赋值操作。

向后兼容：auto_ptr：老版本，具有unique_ptr的部分特性。特别是，不能在容器中保存auto_ptr，也不能从函数返回auto_ptr。

unique_ptr操作

weak_ptr

weak_ptr是一种不控制所指向对象生存期的智能指针。

指向一个由shared_ptr管理的对象，不改变shared_ptr的引用计数。

一旦最后一个指向对象的shared_ptr被销毁，对象就会被释放，不管有没有weak_ptr指向该对象。

weak_ptr操作

动态数组

new和数组

new一个动态数组：

• 类型名之后加一对方括号，指明分配的对象数目（必须是整型，不必是常量）。
• 返回指向第一个对象的指针。
• int *p = new int[size];

delete一个动态数组：

• delete [] p;

unique_ptr和数组：

• 指向数组的unique_ptr不支持成员访问运算符（点和箭头）。

allocator类

• 标准库allocator类定义在头文件memory中，帮助我们将内存分配和对象构造分离开。
• 分配的是原始的、未构造的内存。
• allocator是一个模板。
• allocator<string> alloc;

标准库allocator类及其算法：

allocator伴随算法

• 定义在头文件memory中。
• 在给定目的位置创建元素，而不是由系统分配内存给他们。