《C++Primer》第十七章 标准库特殊设施

2020-12-02  本文已影响0人  TOMOCAT

第十七章 标准库特殊设施

tuple类型

tuple是类似pair的模板，每个pair的成员类型都不相同，但是每个pair恰好有两个成员。我们希望将一些数据组合成单一对象，但又不想麻烦地定义一个新数据结构来表示这些数据，这时候就可以用到tuple。

我们可以将tuple当做一个”快速而随意”的数据结构。

它支持的操作包括：

1. 定义和初始化tuple

使用构造函数：

tuple<size_t, size_t, size_t> threeD;    // 三个成员都值初始化为0
tuple<string, vector<double>, int, list<int>>
    someVal("constants", {3.14, 2.718}, 42, {0,1,2,3,4,5}) // 提供初始值
    
// 注意tuple这个构造函数是explicit的, 因此我们必须使用直接初始化语法:
tuple<size_t, size_t, size_t> threeD = {1, 2, 3};  // 错误
tuple<size_t, size_t, size_t> threeD{1,2,3};       // 正确

也可以使用make_tuple：

auto item = make_tuple("0-999-78345-X", 3, 20.00);

2. 访问tuple的成员

使用get<i>(t)即可返回tuple第i个成员的引用，如果我们不知道tuple准备的类型细节，可以使用两个辅助类模板来查询tuple成员的数量和类型：

typedef decltype(item) trans;          // trans是item的类型(某种tuple)
// 返回trans中成员数量
size_t sz = tuple_size<trans>::value;  // 返回3
// cnt的类型与item中第二个成员相同
tuple_element<1, trans>::type cnt = get<1>(item);  // cnt的类型是一个int

3. 使用tuple返回多个值

tuple的一个常见用途就是从一个函数返回多个相关的值，如果函数返回两个值我们可以使用pair，返回三个值及以上我们就可以使用tuple了。

bitset类型

标注库定义了bitset类让位运算的使用更加容易，并且能够处理超过最长整形类型大小的位集合。

1. 定义和初始化bitset

bitset类似于array类，具有固定的大小。当我们定义一个bitset时需要声明它包含多少个二进制位：

bitset<32> bitvec(1U);  // 32位, 低位为1其他位为0

初始化的方法：

2. bitset操作

正则表达式

正则表达式的组件包括：

其中regex_search和regex_match的参数如下，它们都会返回bool值指出是否找到匹配：

上述表示在字符序列seq中查找regex对象r中的正则表达式，其中seq可以是一个string，表示范围的一对迭代器以及一个指向空字符结尾的字符数组的指针。m是一个match对象，用于保存匹配结果的相关细节。mft是一个可选的regex_constants::match_flag_type值，它们会影响匹配过程。

1. 使用正则表达式库

指定regex对象的选项：

定义regex可选的标志包括：

2. 使用正则表达式的错误

需要意识的一点是，一个正则表达式的语法是否正确是在运行时解析的。

如果我们编写的正则表达式存在错误，则在运行时标准库会抛出一个类型为regex_error的异常：

try {
    // 错误: alnum漏掉了右括号, 构造函数会抛出异常
    regex r("[[:alnum:]+\\.(cpp|cxx|cc)$", regex::icase);
} catch (regex_error e)
    { cout << e.what() << "\ncode:" << e.code() << endl; }

一个正则表达式是在运行时而非编译时编译的，并且正则表达式的编译是一个非常慢的操作，特别是使用了扩展的正则表达式或者是复杂的正则表达式时。为了最小化这种开销，你应该努力避免创建很多不必要的regex，特别是如果你在循环中能够使用正则表达式，那么你应该在循环外创建它而不是在每步迭代时都编译它。

3. 正则表达式类和输入序列类型

输入序列类型 对应的正则表达式类
string regex, smatch, ssub_match, sregex_iterator
const char* regex, cmatch, csub_match, cregex_iterator
wstring wregex, wstmatch, wssub_match, wsregex_iterator
const wchat_t* Wregex, wcmatch, wcsub_match, wcregex_iterator

4. Regex迭代器类型

sregex_iterator操作如下，下面这些操作也适用于cregex_iterator，wsregex_iterator和wcregex_iterator：

// 查找前一个字符不是c的字符串ei
string pattern("[^c]ei");
// 我们想要包含pattern的单词的全部内容
pattern = "[[:alpha:]]*" + pattern + "[[:alpha:]]*";
regex r(pattern, regex::icase);  // 在进行匹配时忽视大小写
// 反复调用regex_search来寻找文件中的所有匹配
for (sregex_iterator it(file.begin(), file.end(), r), end_it; it != end_it; ++it)
    cout << it->str() << endl; // 打印匹配的单词

5. 使用匹配数据

我们可以对smatch进行操作获取匹配的上下文。例如：

for (sregex_iterator it(file.begin(), file.end(), r), end_it; it != end_it; ++it) {
    auto pos = it->prefix().length(); // 前缀的大小
    pos = pos > 40 ? pos - 40 : 0;    // 我们最多要40个字符
    cout << it->prefix().str().substr(pos)   // 前缀的最后一部分, 最多40个字符
        << "\n\t\t>>> " << it->str() << " <<<\n"  // 匹配的单词
        << it->suffix().str().substr(0, 40)       // 后缀的第一部分
        << endl;
}

smatch操作包括，下面这些操作也适用于cmatch，wsmatch，wcmatch和对应的csub_match，wssub_match和wcsub_match：

下面接受一个索引的操作中，n的默认值为0且必须小于m.size()，第一个子匹配（索引为0）表示整个匹配：

6. 使用子表达式

正则表达式中的模板通常包含一个或多个子表达式subexpression，正则表达式语法通常用括号表示子表达式。

// r有两个子表达式: 第一个是点之前表示文件名的部分, 第二个表示文件扩展名
regex r("([[:alnum:]]+)\\.(cpp|cxx|cc)$", regex::icase);

举个例子，美国的电话号码有10个数字，包含一个区号和一个七位的本地号码，区号通常放在括号里里面，但这并不是必须的。剩余的七位数字可以用一个短横线、一个点或者一个空格分隔。但也可以完全不用分隔符。

// 包含7个子表达式: (ddd)分隔符ddd分隔符dddd
// 子表达式1,3,4,6是可选的;2,5,7保存号码
"(\\()?(\\d{3})(\\))?([-. ])?(\\d{3})([-. ])?(\\d{4})"
  1. (\\()?：表示区号部分可选的左括号
  2. (\\d{3})：表示区号
  3. (\\))?：表示区号部分可选的右括号
  4. ([-. ])?：表示区号部分可选的分隔符，横线、点或者空格
  5. (\\d{3})：表示号码的下三位数字
  6. ([-. ])?：可选的分隔符
  7. (\\d{4})：表示号码最后的四位数字

另外需要注意的是，我们希望验证区号部分的数字如果用了左括号，那么它也必须使用右括号，即我们不希望匹配到(908.555.1800这样的号码。下面的代码读取一个文件，用此模式查找与完成的电话号码匹配的数据，然后调用一个valid的函数来检查号码格式是否合法：

string phone = "(\\()?(\\d{3})(\\))?([-. ])?(\\d{3})([-. ])?(\\d{4})";
regex r(phone);  // regex对象, 用于查找我们的模式
smatch m;
string s;
// 从输入文件读取每条记录
while (getline(cin, s)) {
    // 对每个匹配的电话号码
    for (sregex_iterartor it(s.begin(), s.end(), r), end_it; it != end_it; ++it)
        // 检查号码格式是否合法
        if (valid(*it))
            cout << "valid: " << it->str() << endl;
        else
            cout << "not valid: " << it->str() << endl;
}

由于我们的pattern有七个子表达式，每个smatch对象会包含八个ssub_match元素。位置[0]表示整个匹配，[1]...[7]表示每个对应的子表达式。valid函数的写法如下：

bool valid(const smatch& m)
{
    // 如果区号前有一个左括号
    if(m[1].matched)
        // 则区号后必须有一个右括号，后面紧跟剩余号码或一个空格
        retrun m[3].matched
            && (m[4].matched == 0 || m[4].str() == " ");
    else
        // 否则，区号后不能有右括号
        // 令两个组成部分间的分隔符必须匹配
        return !m[3].matched
            && m[4].str() == m[6].str();
}

7. 使用regex_replace

当我们希望在输入序列汇总查找并替换一个正则表达式时，可以调用regex_replace。正则表达式替换操作如下：

使用格式化字符串fmt生成格式化输出，匹配在m中，可选的match_flag_type标志在mft中。第一个版本西而入迭代器dest指向目的地位置并接受fmt参数，可以是一个string也可以用是表示字符数组中范围的一对指针。第二个版本返回一个string，也可以是指向一个空字符结尾的字符数组的指针。mft的默认值是format_default。

遍历seq，用regex_search查找与regex对象r匹配的子串。使用格式字符串fmt和可选的match_flag_type标志来生成输出。

string fmt = "$2.$5.$7";   // 将号码格式改成ddd.ddd.dddd
regex r(phone);
string number = "(908) 555-1800";
cout << regex_replace(number, r, fmt) << endl;
// 输出908.555.1800

随机数

在新标准出现之前，C或者C++都依赖于一个简单的C库函数rand来生成随机数。此函数生成均匀分布的伪随机整数，每个随机数的范围在0和一个系统相关的最大值（至少为32767）之间。

使用rand库函数会带来一个问题：很多程序需要不同范围的随机数，一些与应用需要随机浮点数而另一些应用需要非均匀分布的数。程序员为了解决这些问题而试图转换rand生成的随机数的范围、类型或者分布时，常常会引入非随机性。

1. 随机数引擎和分布

我们可以调用一个随机数引擎对象来生成原始随机数：

default_random_engine e;  // 生成随机无符号数
for (size_t i = 0; i < 10; ++i) 
    // e() "调用"对象来生成下一个随机数
    cout << e() << " ";

随机数引擎的操作如下：

使用分布：

// 生成0~9之间（包含0和9）均匀分布的随机数
uniform_int_distribution<unsigned> u(0,9);
default_random_engine e;
for (size_t i = 0; i < 10; ++i)
    // 将u作为随机数源
    // 每个调用返回在指定范围内并服从均匀分布的值
    cout << u(e) << endl;

2. 序列不变性问题

即使生成的数看起来是随机的，但是对于一个给定的发生器，每次运行程序它都会返回相同的数值序列。下面这种写法每次调用这个函数都会返回相同的100个数：

// 几乎肯定是生成随机整数vector的错误方法
// 每次调用都会生成相同的100个整数
vector <unsigned> bad_randVec()
{
    default_random_engine e;
    uniform_int_distribution<unsigned> u(0, 9);
    vector<unsigned> ret;
    for (size_t i = 0; i < 100; ++i)
        ret.push_back(u(e));
    return ret;
}

正确的方法是将引擎和关联的分布对象定义为static的：

// 返回一个vector, 包含100个均匀分布的随机数
vector <unsigned> bad_randVec()
{
    static default_random_engine e;
    static uniform_int_distribution<unsigned> u(0, 9);
    vector<unsigned> ret;
    for (size_t i = 0; i < 100; ++i)
        ret.push_back(u(e));
    return ret;
}

由于e和u是static的，因此它们会在函数调用之间保持住状态，第一次调用会使用u(e)生成的序列的前100个随机数，第二次调用会获得接下来100个，从而不会完全相同。

3. 使用种子

default_random_engine e1(time(0));  // 稍微随机些的种子

由于time返回以秒计的时间，因此这种方法只适用于生成种子的间隔为秒级或更长时间的应用。

4. 分布类型

分布类型的操作如下：

常用的分布类型：

default_random_engine e;

uniform_real_distribution<double> u(0,1);  // 0到1(包含0和1)的均匀分布
normal_distribution<> n(4,1.5);            // 均值4, 标准差1.5的正态分布

vector<unsigned> vals(9);  // 9个元素均为0
for (size_t i = 0; i != 200; ++i) {
    unsigned v = lround(n(e));   // 舍入到最接近的整数
    if (v < vals.size())         // 如果结果在范围内
        ++vals[v];               // 统计每个结果出现的次数
}

// 用于统计0~9附近各出现了多少次, 结果呈现一个正态分布

还有伯努利分布：

default_random_engine e;
bernoulli_distribution b;
b(e);  // 50%的几率返回true, 50%几率返回false

IO库再探

1. 格式化输入和输出

2. 未格式化的输入/输出操作

前面我们提到的输入运算符忽略空白符，输出运算符应用补白、精度等规则。标准库还提供了一组低层操作，支持未格式化IO，这些操作允许我们将一个流当做一个无解释的字节序列来处理。

2.1 单字节操作

有几个未格式化操作每次一个字节地处理流，它们会读取而不是忽略空白符。例如我们使用未格式化IO操作get和put来读取和写入一个字符：

char ch;
while (cin.get(ch))
    cout.put(ch);

具体操作包括：

2.2 多字节操作

3. 流随机访问

标准库提供了一对函数，来定位seek到流中给定的位置，以及告诉tell我们当前位置。虽然标准库为所有流类型都定义了seek和tell函数，但是他们是否会做又有意义的事情依赖于流绑定到哪个设备。在大多数系统中，绑定到cin，cout，cerr和clog的流不支持随机访问。对于这些流我们可以调用seek和tell函数，但在运行时会出错，将流置于一个无效状态。

由于istream和ostream通常不支持随机访问，因此本节内容只适用于fstream和sstream。

3.1 seek和tell函数
3.2 重定位标记

seek函数有两个版本：一个移动到文件中的“绝对”地址，另一个移动到给定位置的指定偏移量

// 将标记移动到一个固定位置
seekg(new_position);  // 将读标记移动到指定的pos_type类型的位置
seekp(new_position);  // 将写标记移动到指定的pos_type类型的位置

// 移动到给定起始点之前或之后指定的偏移位置
seekg(offset, from);  // 将度标记移动到距from偏移量为offset的位置
seekp(offset, from);  // 将写标记移动到距from偏移量为offset的位置
3.3 访问标记

函数tellg和tellp返回一个pos_type值，表示流的当前位置。tell函数通常用来记住一个位置，以便稍后再定位回来：

// 记住当前写位置
ostringstream writeStr;   // 删除stringstream
ostringstream::pos_type mark = writeStr.tellp();

// ...
if (cancelEntry)
    // 回到刚才记住的位置
    writeStr.seekp(mark);
3.4 实例

给定一个文件：

abcd
efg
hi
j

我们需要在文件的末尾写入一行，这一行包含文件中每行的相对起始位置，写完后为：

abcd
efg
hi
j
5 9 12 14

int main()
{
    // 以读方式打开文件，并定位到文件尾
    fstream inOut("copyOut", fstream::ate | fstream::in | fstream::out);
    if(!inOut) {
        cerr << "Unable to open file!" << endl;
        return EXIT_FAILURE;
    }
    // inOut以ate模式打开，因此一开始就定义到其文件尾
    auto end_mark = inOut.tellg();   // 记住原文件尾位置
    inOut.seekg(0, fstream::beg);    // 重定位到文件开始
    size_t cnt = 0;                  // 字节数累加器
    string line;                     // 保存输入中的每行
    // 继续读取的条件: 还未遇到错误且还在读取原数据
    while (inOut && inOut.tellg() != end_mark && getline(inOut, line)) {  // 且还可以获取一行输入
        cnt += line.size() + 1;         // +1表示换行符
        auto mark = inOut.tellg();      // 记住读取位置
        inOut.seekp(0, fstream::end);   // 将写标记拖动到文件末尾
        intOut << cnt;                  // 输出累计的长度
        // 如果不是最后一行，打印一个分隔符
        if (mark != end_mark) inOut << " ";
        inOut.seekg(mark);              // 恢复读位置
    }
    inOut.seekp(0, fstream::end);       // 定位到文件尾
    inOut << "\n";                      // 在文件末尾输出一个换行符
    return 0;
}
上一篇 下一篇

猜你喜欢

热点阅读