C++ primer 第17章 标准库特殊设施

1
2
3
4
5

tuple<size_t,size_t,size_t> threeD;             //值初始化每个成员
tuple<string,vector<double>,int,list<int>> someVal("constants",{3.14,2.718},42,{0,1,2,3});
tuple<size_t,size_t,size_t> threeD={1,2,3};     //错，接受初始值的构造函数是explicit，不可类型转换
tuple<size_t,size_t,size_t> threeD{1,2,3};      //对，可直接初始化
auto item=make_tuple("0-999-78345-X",3,20.00);  //使用make_tuple来构造

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

auto item=make_tuple("0-999-78345-X",3,20.00);  //使用make_tuple构造一个tuple
//访问成员
auto book=get<0>(item);                         //取第一个成员
auto cnt=get<1>(item);
auto price=get<2>(item)/cnt;
get<2>(item)*=0.8;                              //get取的成员是引用，可以修改tuple内部
//求tuple类型的详细信息
typedef decltype(item) trans;                   //定义类型别名
size_t sz=tuple_size<trans>::value;             //从tuple的类型中得到成员的数量：tuple_size
tuple_element<1,trans>::type cnt=get<1>(item);  //从tuple的类型中得到成员的类型：tuple_element

1
2
3
4
5
6
7

tuple<string,string> duo("1","2");
tuple<size_t,size_t> twoD(1,2);
bool b=(duo==twoD);                         //错，不能比较元素类型string和size_t
tuple<size_t,size_t,size_t> threeD(1,2,3);
b=(twoD<threeD);                            //错，成员数量不同不能比较
tuple<size_t,size_t> origin(0,0);
b=(origin<twoD);                            //对，b为true

 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

/* 背景：Sales_data是一本书的销售资料
 *      vector<Sales_data>是一家书店所有书的销售资料
 *      vector<vector<Sales_data>>是多家书店的所有书的销售资料
 * 任务：给定所有书店的所有书的销售记录，输入一本书名，打印这本书在所有书店的销售记录
 */
//tuple表示一本书在一家书店的销售记录：第一个参数代表第几家书店，第二三个参数代表这本书在这家书店的迭代器范围
using matches=tuple<vector<Sales_data>::size_type,
                    vector<Sales_data>::const_iterator,
                    vector<Sales_data>::const_iterator>;
//返回tuple的vector，即这本书在所有书店的销售记录
//参数是所有书店所有书的销售记录files和要查找的书名book
vector<matches> findBook(const vector<vector<Sales_data>> &files,const string &book){
    vector<matches> ret;
    //遍历书店
    for(auto it=files.cbegin();it!=files.cend();++it){
        //使用equal_range在一家书店的vector中查找相同的书
        //equal_range类似关联容器的equal_range，以pair形式返回一个给定值存在的区间（要求相等元素相邻存储）
        //使用自定义谓词compareIsbn，书名相等即Sales_data相等
        //传入book是string，存在由string到Sales_data的自动转换（由Sales_data的构造函数实现）
        auto found=equal_range(it->cbegin(),it->cend(),book,compareIsbn);
        //equal_range返回的迭代器区间若非空，则存在与给定值相等的元素
        if(found.first!=found.second)
            //使用make_tuple构造一个tuple
            //it-files.cbegin()是随机访问迭代器的操作，其结果是当前书店的编号（到第一家书店的距离）
            ret.push_back(make_tuple(it-files.cbegin(),found.first,found.second));
    }
    return ret;
}
//调用上面的函数，打印结果
void reportResults(istream &in,ostream &os,const vector<vector<Salse_data>> &files){
    string s;
    while(in>>s){
        //调用查找的结果，trans是vector<matches>
        auto trans=findBook(files,s);
        if(trans.empty()){
            cout<<s<<" not found in any stores"<<end;
            continue;
        }
        //将auto扩展为const auto &，声明的是这个类型的常量引用
        for(const auto &store:trans)
            //使用get<num>(tuple)来取tuple的成员
            os<<"store "<<get<0>(store)<<" sales: "
              //能用accumulate是因为对Salse_data重载了operator+，求和起点是临时构建的对象
              <<accumulate(get<1>(store),get<2>(store),Sales_data(s))
              <<endl;
    }
}

1
2
3

bitset<13> bitvec1(0xbeef); //ull更长，高位被丢弃：1 1110 1110 1111
bitset<20> bitvec2(0xbeef); //bitset更长，高位填0：0000 1011 1110 1110 1111
bitset<128> bitvec3(~0ULL); //bitset更长，高位填0：低64位是1，高64位是0

1
2
3
4

bitset<32> bitvec4("1100");             //字符串下标小的字符对应高位，初始化为1100
string str("1111111000000011001101");
bitset<32> bitvec5(str,5,4);            //取子串， 从str[5]开始取4个比他，初始化为1100
bitset<32> bitvec6(str,ste.size()-4);   //取子串，从倒数第4个开始直到末尾，初始化为1101

 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

bitset<32> bitvec(1U);
//不接受参数的操作
bool is_set=bitvec.any();               //是否有任何一位是1
bool is_not_set=bitvec.none();          //是否全为0
bool all_set=bitvec.all();              //是否全为1
size_t onBits=bitvec.count();           //1的个数
size_t sz=bitvec.size();                //有多少位
bitvec.flip();                          //翻转所有位
bitvec.reset();                         //所有位置0
bitvec.set();                           //所有位置1
//接受参数的操作
bitvec.flip(0);                         //将最低位翻转
bitvec.set(bitvec.size()-1);            //将最高位置1
bitvec.set(0,0);                        //将最低位置0
bitvec.reset(i);                        //将第i位置0
bitvec.test(0);                         //最低位是否为1
//下标操作
bitvec[0]=0;                            //下标可写
bitvec[31]=bitvec[0];                   //下标可读可写
bitvec[0].flip();                       //可对某一位使用bitset操作
~bitvec[0];                             //可对某一位使用内置类型的位运算
bool b=bitvec[0];                       //可将某一位赋值给（转换为）bool
//转换为unsigned long
unsigned long ulong=bitvec.to_ulong();  //转为unsigned long
cout<<"ulong="<<ulong<<endl;
//IO算符
bitset<16> bits;
cin>>bits;                              //将输入的'0'/'1'读为string并初始化bitset
cout<<"bits:"<<bits<<endl;              //将bitset中的bit转为'0'/'1'打印
//兼容内置类型的位运算
unsigned long quizA=0;                  //用unsigned long表示至少32个bit
quizA|=1UL<<27;                         //将第27位置1
bool status=quizA&(1UL<<27);            //求第27位的状态
quizA&=~(1UL<<27);                      //将第27位置0
//与位运算等价的bitset操作，有更好的可读性
bitset<30> quizB;                       //只需30个bit，用大小为30的bitset
quizB.set(27);                          //将第27位置1
status=quizB[27];                       //求第27位的状态
quizB.reset(27);                        //将第27位置0

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

/* ECMAScript正则表达式语法:
 * [^c]匹配任意非'c'的字符
 * [^c]ei匹配任意非c的字符后接ei的字符串
 * [[:alpha:]]匹配任意字母
 * +和*分别表示“一个或多个”和“零个或多个”匹配
 * [[:alpha:]]*匹配零个或多个字母
 * 综上，[[:alpha:]]*[^c]ei[[:alpha:]]*表示：匹配出现任意非c的字符后接ei的字符串的单词
 */
string pattern("[^c]ei");
pattern="[[:alpha:]]*"+pattern+"[[:alpha:]]*";  //构建正则表达式的字符串描述
regex r(pattern);                               //创建正则表达式regex对象
smatch results;                                 //创建匹配的结果对象
string test_str="receipt freind theif receive"; //要查找模式的字符串
//regex_search匹配字符串的子串，如果匹配成功，返回true并将结果存在results中
if(regex_search(test_str,results,r))
    cout<<results.str()<<endl;                  //打印匹配的结果，输出将是freind（匹配到的第一个）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

/* ECMAScript正则表达式语法:
 * [[:alnum:]]匹配字母或数字
 * [[:alnum:]]+匹配一个或多个字母或数字
 * .匹配任意字符
 * 由于.在正则表达式语法中有特殊含义，故加上\
 * 由于\在c++字符串中有特殊含义，故再加一个\
 * 综上，\\.匹配字符串中的字符'.'
 * cpp|cxx|cc是或逻辑，匹配cpp或cxx或cc
 * (cpp|cxx|cc)加上括号是子表达式
 */
regex r("[[:alnum:]]+\\.(cpp|cxx|cc)$",regex::icase);   //匹配时忽略大小写
smatch results;
string filename;
while(cin>>filename)
    if(regex_search(filename,results,r))
        cout<<results.str()<<endl;

1
2
3
4
5
6
7
8

try{
    //创建正则表达式时可能抛出异常（由于正则表达式书写错误），用try捕获异常
    regex r("[[:alnum:]+\\.(cpp|cxx|cc)$",regex::icase);    //书写错误：[[:alnum:]应为[[:alnum:]]
}
catch(regex_error e){
    //创建正则表达式时抛出的异常regex_error有what和code两个成员函数
    cout<<e.what()<<" \ncode: "<<e.code()<<endl;
}

1
2
3
4
5
6
7
8

//regex不区分string和字符数组
regex r("[[:alnum:]]+\\.(cpp|cxx|cc)$",regex::icase);
smatch results;                         //结果存在string中
if(regex_search("myfile.cc",results,r)) //错，输入序列"myfile.cc"是字符数组，与smatch不统一
    cout<<results.str()<<endl;
cmatch results;                         //结果存在字符数组中
if(regex_search("myfile.cc",results,r)) //对，输入序列"myfile.cc"和cmatch统一
    cout<<results.str()<<endl;

1
2
3
4
5
6
7
8

string pattern("[^c]ei");
pattern="[[:alpha:]]*"+pattern+"[[:alpha:]]*";
regex r(pattern,regex::icase);
//假定file是string类型，保存要搜索的字符串
//创建两个sregex_iterator，第一个初始化为第一个匹配，第二个初始化为尾后迭代器
//使用递增来遍历每一个匹配位置
for(sregex_iterator it(file.begin(),file.end(),r),end_it;it!=end_it;++it)
    cout<<it->str()<<endl;

1
2
3
4
5
6
7
8
9

/* for之前的部分和上一个例子一样 */
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个字符，则完整打印前面部分，否则打印前面40个字符
    cout<<it->prefix().str().substr(pos)    //打印匹配部分的上文
        <<"\n\t>>> "<<it->str()<<" <<<\n"   //打印匹配部分，并在两侧加上箭头强调
        <<it->suffix().str().substr(0,40)   //打印匹配部分的下文
        <<endl;
}

 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

/* ECMAScript正则表达式语法：
 * (\\()?是子表达式，匹配字符'('，表示区号部分可选的左括号
 * (\\d{3})是子表达式，匹配3个数字，表示区号
 * (\\))?是子表达式，匹配字符')'，表示区号部分可选的右括号
 * ([-. ])?是子表达式，匹配字符'-'或'.'或' '，表示区号部分可选的分隔符
 * (\\d{3})是子表达式，匹配3个数字，表示号码下三位数字
 * ([-. ])?是子表达式，匹配字符'-'或'.'或' '，表示可选的分隔符
 * (\\d{4})是子表达式，匹配4个数字，表示号码最后四位
 */
string phone="(\\()?(\\d{3})(\\))?([-. ])?(\\d{3})([-. ])?(\\d{4})";
regex r(phone);
smatch m;
srting s;
//判断一个被正则表达式匹配到的字符串是否是电话号码（即是否符合进一步的标准）
bool valid(const smatch &m){
    if(m[1].matched)
        //若左边括号被匹配到，则右边括号必须也被匹配，且满足某个先验
        return m[3].matched && (m[4].matched==0 || m[4].str()==" ");
    else
        //若左边括号未被匹配到，则右边括号也必须未被匹配，且满足某个先验
        return !m[3].matched && m[4].str()==m[6].str();
}
//逐行处理匹配到的电话号码
while(getline(cin,s)){
    //使用sregex_iterator遍历一行中的所有匹配
    for(sregex_iterator it(s.begin(),s.end(),r),end_it;it!=end_it;++it)
        //对每个匹配到的结果通过valid分析子串，进一步判断是否是电话号码
        if(valid(*it))
            cout<<"valid: "<<it->str()<<endl;
        else
            cout<<"not valid: "<<it->str()<<endl;
}

1
2
3
4
5

string phone="(\\()?(\\d{3})(\\))?([-. ])?(\\d{3})([-. ])?(\\d{4})";
regex r(phone);
string fmt="$2.$5.$7";                      //定义输出格式为第2,5,7个子串，中间用'.'分隔
string number="(908) 555-1800";             //输入(908) 555-1800
cout<<regex_replace(number,r,fmt)<<endl;    //输出908.555.1800

1
2
3
4
5
6

string phone="(\\()?(\\d{3})(\\))?([-. ])?(\\d{3})([-. ])?(\\d{4})";
regex r(phone);
string fmt="$2.$5.$7 ";                                 //定义输出格式为第2,5,7个子串，中间用'.'分隔，末尾加空格
string number="morgan (201) 555-2368 862-555-0123";     //输入morgan (201) 555-2368 862-555-0123
cout<<regex_replace(number,r,fmt)<<endl;                //输出morgan 201.555.2368  862.555.0123
cout<<regex_replace(number,r,fmt,format_no_copy)<<endl; //输出201.555.2368 862.555.0123

1
2
3

default_random_engine e;    //随机数引擎是可调用对象
for(size_t i=0;i<10;++i)
    cout<<e()<<" ";         //每次调用生成原始随机序列中的一个值

1
2
3
4

uniform_int_distribution<unsigned> u(0,9);  //分布类，指定生成随机数的范围、类型、分布
default_random_engine e;                    //引擎类，用于生成原始随机数
for(size_t i=0;i<10;++i)
    cout<<u(e)<<" ";                        //使用引擎类对象调用分布类对象，生成随机数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

//每次调用都创建随机数发生器，则每次调用生成的随机序列都相同
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;
}
//每次调用bad_randVec都重新创建随机数发生器，故v1和v2内容相同
vector<unsigned> v1(bad_randVec());
vector<unsigned> v2(bad_randVec());
//将随机数发生器声明为static，避免多次创建。从同一序列中取随机数，保证每次取的值都不同
vector<unsigned> good_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;
}
//每次调用good_randVec都使用同一个随机数发生器，保证不重复
vector<unsigned> v3(good_randVec());
vector<unsigned> v4(good_randVec());

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

default_random_engine e1;               //e1不指定种子
default_random_engine e2(2147483646);   //e2创建时提供种子2147483646
default_random_engine e3;
e3.seed(32767);                         //e3使用seed函数提供种子32767
default_random_engine e4(32767);        //e4创建时提供种子32767
for(seize_t i=0;i!=100;++i){
    if(e1()==e2())
        cout<<"unseeded match at iteration: "<<i<<endl; //e1和e2种子不同，生成不同的序列
    if(e3()！=e4())
        cout<<"seeded differs at iteration: "<<i<<endl; //e3和e4种子相同，生成相同的序列
}

1

default_random_engine e1(time(0));

1
2
3
4

default_random_engine e;                    //随机数引擎
uniform_real_distribution<double> u(0,1);   //随机数分布，生成0到1之间的均匀随机数
for(size_t i=0;i<10;++i)
    cout<<u(e)<<" "<<endl;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

default_random_engine e;                        //随机数引擎
normal_distribution<> n(4,1.5);                 //随机数分布，生成均值为4标准差为1.5的正态分布
vector<unsigned> vals(9);                       //用vector存放每个区间内随机数的数量
for(size_t i=0;i!=200;++i){                     //生成200个随机数
    unsigned v=lround(n(e));                    //将正态分布的随机数向下取整
    if(v<vals.size())                           //只需判断一侧边界是因为unsigned把负数移到最大值处
        ++vals[v];                              //区间内计数增加
}
for(size_t j=0;j!=vals.size();++j)
    cout<<j<<": "<<string(vals[j],'*')<<endl;   //以字符'*'的数量可视化区间内随机数的数量

1
2
3
4

cout<<"default bool values: "<<true<<" "<<false //默认设置下打印bool
    <<"\nalpha bool values: "<<boolalpha<<      //使用操纵符boolalpha设置流，后续打印bool都是true/false
    <<true<<" "<<false                          //使用boolalpha的设置下打印bool
    <<noboolalpha<<endl;                        //恢复为默认状态noboolalpha，后续打印bool都是0/1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

//调整进制
cout<<"default: "<<20<<" "<<1024<<endl;         //打印：20 1024
cout<<"octal: "<<oct<<20<<" "<<1024<<endl;      //打印：24 2000
cout<<"hex: "<<hex<<20<<" "<<1024<<endl;        //打印：14 400
cout<<"decimal: "<<dec<<20<<" "<<1024<<endl;    //打印：20 1024
//调整前导字符
cout<<showbase;
cout<<"default: "<<20<<" "<<1024<<endl;         //打印：20 1024
cout<<"octal: "<<oct<<20<<" "<<1024<<endl;      //打印：024 02000
cout<<"hex: "<<hex<<20<<" "<<1024<<endl;        //打印：0x14 0x400
cout<<"decimal: "<<dec<<20<<" "<<1024<<endl;    //打印：20 1024
cout<<noshowbase;
//调整十六进制的大小写
cout<<uppercase<<showbase<<hex                  //设置以十六进制打印，打印前导字符，以大写打印
    <<"printed in hexadecimal: "<<20<<" "<<1024 //打印：0X14 0X400
    <<nouppercase<<noshowbase<<dec<<endl;       //复原成默认设置

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

//precision成员函数得到当前精度
cout<<"precision: "<<cout.precision()
    <<", value: "<<sqrt(2.0)<<endl;
//precision成员函数将精度设置为12，precision成员函数得到当前精度
cout.precision(12);                     //使用precision成员函数的形式是cout调用
cout<<"precision: "<<cout.precision()
    <<", value: "<<sqrt(2.0)<<endl;
//setprecision操纵符将精度设置为3，precision成员函数得到当前精度
cout<<setprecision(3);                  //使用setprecision操纵符的形式是用输出算符输出
cout<<"precision: "<<cout.precision()
    <<", value: "<<sqrt(2.0)<<endl;

1
2
3
4
5
6
7
8

cout<<"default format: "<<100*sqrt(2.0)<<'\n'               //打印：141.421
    <<"scientific: "<<scientific<<100*sqrt(2.0)<<'\n'       //打印：1.414214e+002
    <<"fixed decimal: "<<fixed<<100*sqrt(2.0)<<'\n'         //打印：141.421356
    <<"hexadecimal: "<<hexfloat<<100*sqrt(2.0)<<'\n';       //打印：0x1.1ad7bcp+7
    <<"use defaults: "<<defaultfloat<<100*sqrt(2.0)<<'\n';  //打印：141.421
cout<<10.0<<endl;                                           //打印：10
cout<<showpoint<<10.0                                       //打印：10.000
    <<noshowpoint<<endl;                                    //恢复默认的不打印小数点和小数部分

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

int i=-16;
double d=3.14159;
cout<<"i: "<<setw(12)<<i<<"next col\n"  //打印：i:          -16next col
    <<"d: "<<setw(12)<<d<<"next col\n"; //打印：d:      3.14159next col
cout<<left
    <<"i: "<<setw(12)<<i<<"next col\n"  //打印：i: -16         next col
    <<"d: "<<setw(12)<<d<<"next col\n"  //打印：d: 3.14159     next col
    <<right;
cout<<right
    <<"i: "<<setw(12)<<i<<"next col\n"  //打印：i:          -16next col
    <<"d: "<<setw(12)<<d<<"next col\n"; //打印：d:      3.14159next col
cout<<internal
    <<"i: "<<setw(12)<<i<<"next col\n"  //打印：i: -         16next col
    <<"d: "<<setw(12)<<d<<"next col\n"; //打印：d:      3.14159next col
cout<<setfill('#')
    <<"i: "<<setw(12)<<i<<"next col\n"  //打印：i: -#########16next col
    <<"d: "<<setw(12)<<d<<"next col\n"  //打印：d: #####3.14159next col
    <<setfill(' ');

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

char ch;
//默认不读取空白
/* 输入：a b    c
 *      d
 * 输出：abcd
 */
while(cin>>ch)
    cout<<ch;
//使用noskipws读取空白
cin>>noskipws;
/* 输入：a b    c
 *      d
 * 输出：a b    c
 *      d
 */
while(cin>>ch)
    cout<<ch;
cin>>skipws;    //恢复默认行为

1
2
3

int ch;                     //使用int保存流中读取的字符，不可用char
while((ch=cin.get())!=EOF)  //使用EOF常量，不需要记住其具体数值
    cout.put(ch);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

char ch;                    //使用char保存流中读取的字符
while((ch=cin.get())!=EOF)  //将读到的int转换为char并与EOF比较
    cout.put(ch);
/* 若该机器上char是unsigned char：
 * int被转换为unsigned char，读到EOF（负数）时下溢，
 * 因此永远不可能满足==EOF，循环永远不会停止
 */
/* 若该机器上char是signed char：
 * int被转换为signed char，也可能发生溢出，该行为是未定义
 * 很多机器上可正常工作，除非输入序列有一个字符与EOF匹配
 * 有的机器上EOF是-1，将-1转换为signed char得到'\377'，若输入中遇到这个值，则提前停止
 */

 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

/* 任务：给定文件，在文件尾添加一行，记录每一行的起始在文件中的位置（除第一行外）
/* 输入：
 * abcd
 * efg
 * hi
 * j
 */
/* 输出：
 * abcd
 * efg
 * hi
 * j
 * 5 9 12 14
 */
//打开文件，定位到末尾，并以可读可写模式打开
std::fstream inOut("copyOut",std::fstream::ate|std::fstream::in|std::fstream::out);
//打开文件操作无效时报错并退出
if(!inOut){
    std::cerr<<"Unable to open file!"<<std::endl;
    return EXIT_FAILURE;
}
//记录文件尾的位置，由于打开时已定位到末尾，故返回的是当前位置
auto end_mark=inOut.tellg();
//重定位到文件开始，使用相对位置时可从fstream::beg/fstream::cur/fstream::end开始
inOut.seekg(0,std::fstream::beg);
size_t cnt=0;                           //计数器记录当前位置
std::string line;                       //string存储每次读取的一行
//当流还有效、未读到末尾、成功取到一行时
while(inOut && inOut.tellg()!=end_mark && getline(inOut,line)){
    cnt+=line.size()+1;                 //计数
    auto mark=inOut.tellg();            //记录当前位置
    inOut.seekp(0,std::fstream::end);   //将流定位到文件末尾
    inOut<<cnt;                         //将计数写入文件末尾
    if(mark!=end_mark)                  //若未到达打开时的文件尾，则打印空格，准备写入下一个行号
        inOut<<" ";
    inOut.seekg(mark);                  //回到计数时的位置
}
inOut.seekp(0,std::fstream::end);
inOut<<"\n";                            //在文件末尾写入换行符