// chapter-17.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include<iostream>
#include<tuple>
#include<vector>
#include<string>
#include<bitset>
#include<regex>
#include<random>
#include<ctime>
#include<cmath>

using namespace std;
using namespace std::regex_constants;       //regex的匹配标志命名空间

vector<unsigned> good_value()
{
    static default_random_engine e;
    static uniform_int_distribution<unsigned> u(0, 9);
    vector<unsigned> ret;
    for (size_t i = 0; i < 10; ++i)
    {
        ret.push_back(u(e));
    }
    return ret;
}

int main()
{
    //tuple是一个快速而随意的数据结构，其构造函数为explicit！实参和返回值都是字面值常量！
    tuple<size_t, size_t, size_t> threeD;
    tuple<string, vector<int>> someVal("aaa", { 1,2,3 });
    auto item = make_tuple("00123", 3,150.0);
    //访问成员，通过get<>()函数访问成员！
    auto book = get<0>(item);
    auto cnt = get<1>(item);
    get<2>(item) *= 0.8;
    //查询tuple的类型
    using trans=decltype(item);
    size_t sz = tuple_size<trans>::value;               //成员数量
    tuple_element<1, trans>::type element_1 = get<1>(item); //获取对应成员的类型！
    //tuple进行关系和相等比较时，必须成员数量相同，且每队成员可以使用==运算符或者<运算符！
    tuple<string, string> compare_one("a", "b");
    tuple<string, string> compare_two("a", "c");
    if (compare_one < compare_two)
        cout << "One < Two!" << endl;
    //tuple常用于函数返回多值！返回索引和首尾迭代器！

    //bitset，具有固定大小，且不能改变！
    bitset<32> bitvec(1u);          //构造函数为constexpr，参数必须是字面值类型！
    //初始化方法
    //bitset<n> b
    //bitset<n> b(u)                //b为unsigned long long值u的低n位拷贝，如果超出则高位置0！
    //bitset<n> b(s,pos,m,zero,one) //b是从string的pos开始的m个字符的拷贝，string只能包含zero和one！
    //bitset<n> b(cp,pos,m,zero,one)
    bitset<13> bitval1(0xbeef);     //1111011101111         高位被丢弃
    bitset<20> bitval2(0xbeef);     //0000101 1111011101111 高位补0
    string str("1111111000000011001101");
    bitset<5> bitval3(str, 5, 4);   //01100
    bitset<5> bitval4("1100");      //01100
    cout << bitval1 << " " << bitval2 << " " << bitval3 << " " << bitval4 << endl;

    //bitset的操作
    //b.any()               b中是否存在置位的二进制,返回bool
    //b.all()               b中所有都置位了吗？
    //b.none()              b中不存在置位的二进制
    //b.cout()              b中置位的位数，返回size_t
    //b.size()              一个constexpr函数，返回？？？？？
    //b.test(pos)           若pos置位则返回true
    //b.set(pos,v)          将pos的位设置为bool值v，若无实参则将b中所有位置位
    //b.set()
    //b.reset(pos)          复位
    //b.reset()
    //b.flip(pos)           改变pos处的位状态
    //b.flip()
    //b[pos]                访问b中pos处的位！
    //b.to_long()
    //b.to_ullong()
    //b.to_string(zero,one) zero和one的默认值分别为0和1，用来表示b中的0和1！
    //os<<b                 将b中二进制位打印！
    //is>>b

    //正则表达式
    //regex                 正则表达式的类
    //regex_match           将字符序列与正则表达式匹配
    //regex_search          寻找第一个与正则表达式匹配的序列
    //regex_replace         使用给定格式替换一个正则表达式
    //sregex_iterator       迭代器，调用regex_search来遍历一个string
    //smatch                容器类，保存在string中的搜索结果.(cmatch,保存const char*的结果)
    //ssub_match            string中匹配的子表达式的结果
    //regex_search和regex_match的参数，返回bool。指出是否找到匹配
    //(seq,m,r,mft)     seq可以为string或者一对迭代器或者指向空字符结尾的字符串，m为一个match对象，保存匹配结果；r为正则表达式；mft是一个可选的值，影响匹配过程！
    //(seq,r,mft)
    string pattern("[^c]ei");
    pattern = "[[:alpha:]]*" + pattern + "[[:alpha:]]*";
    regex r(pattern);
    smatch results;
    string test_str = "receipt freind theif receive";
    if (regex_search(test_str, results, r))
        cout << results.str() << endl;
    
    //regex的操作
    //regex r(re)       re可以使string、字符范围迭代器、指向空字符结尾的字符数组、字符指针和计数器等等；
    //regex r(re,f)     f指出对象如何被处理，默认值为ECMAScript
    //r1=re             正则表达式拷贝，re可以为正则表达式或者string！
    //r1.assign(re,f)   同上
    //r.mark_count()    r中子表达式的数目
    //r.flags()         返回r的标志集
    //icase 匹配时忽略大小写    nosubs不保存匹配的子表达式        optimize执行速度优先于构造速度     ECMAScript指定语法      basie       extended        awk     grep        egrep
    regex r_cpp("([[:alnum:]]+)\\.(cpp|cxx|cc)$", regex::icase);    //一个或多个字母或数字后接一个.，再接一个cpp或cxx或cc。
    
    //正则表达式在regex对象初始化时检查错误，标准库定义了regex_error的异常类，含有what和code成员函数！
    //使用正则表达式时，应该避免多次构造regex对象和regex赋值，特别应该在循环外创建regex对象！
    //正则表达式输入类型和输出类型应该一致；string--regex--smatch--ssub_match--sregex_iterator//const char*--regex--cmatch--csub_match--cregex--iterator

    //Regex的迭代器，包含*it、it->、++it、it++、it1==it2、it1！=it2操作！
    for (sregex_iterator it(test_str.begin(), test_str.end(), r), end_it; it != end_it; ++it)       //test_str为要查找的string字符串！end_it为尾后迭代器！
    {
        cout << it->str() << endl;
    }

    //smatch对象包含的操作
    //m.ready()             匹配成功返回true
    //m.size()              返回最近一次匹配的正则表达式中子表达式的数目
    //m.empty()             若m.size（）为0，则返回true
    //m.perfix()
    //m.suffix()
    //m.format()

    //m.length(n)           子表达式序列索引！
    //m.position(n)
    //m.str(n)
    //m[n]
    //m.begin(),m.end()
    for (sregex_iterator it(test_str.begin(), test_str.end(), r), end_it; it != end_it; ++it)       //test_str为要查找的string字符串！end_it为尾后迭代器！
    {
        cout << it->prefix().str() << "=" << it->str() << "=" << it->suffix().str() << endl;        // it->prefix().str()  it->str()  it->suffix().str()    smatch对象！prefix返回一个ssub_match对象！
    }
    //regex r_cpp("([[:alnum:]]+)\\.(cpp|cxx|cc)$", regex::icase);正则表达式，包含2个子表达式，通过括号进行分组！
    string filename = "foo.cpp";
    smatch result_cpp;
    if (regex_search(filename, result_cpp, r_cpp))
        cout << result_cpp.str(0) << "//" << result_cpp.str(1) << "//" << result_cpp.str(2) << endl;
    
    //ssub_match子匹配操作，子表达式常用于验证数据！
    //matched       指出ssub_match是否匹配了
    //first         返回首尾迭代器
    //second
    //length()      返回匹配的子表达式的长度
    //str()         返回对应string
    //s=ssub        将ssub转为string对象！

    //正则表达式替换操作regex_replace
    //m.format(dest,fmt,mft)                使用格式字符串fmt生成格式化输出；dest表示迭代器
    //m.format(fmt,mft)                     mft为匹配标志！

    //regex_replace(dest,seq,r,fmt,mft)～dest表示什么？
    //regex_replace(seq,r,fmt,mft)
    string info = "aaa (201) 555-2368 862-555-0123 (973)555.0130 2015550175";
    string phone = "(\\()?(\\d{3})(\\))?([-. ])?(\\d{3})([-. ])?(\\d{4})";
    regex r_phone(phone);
    smatch m_p;
    string fmt = "$2.$5.$7";        //输出第2、5、7子序列！
    string fmt2 = "$2.$5.$7 \\ ";
    cout << regex_replace(info, r_phone, fmt) << endl;
    cout << regex_replace(info, r_phone, fmt2,format_no_copy) << endl;//format_no_copy表示不输出序列中未匹配的部分！

    //随机数，头文件random。引擎类，生成随机unsigned整数序列；分布类型，使用引擎返回服从特定概率分布的随机数
    default_random_engine e;        //标准库定义了多个随机数引擎类型！
    for (size_t i = 0; i < 10; ++i)
    {
        cout << e() << " ";
    }
    cout << endl;
    //随机数引擎的操作
    //Engine e;             创建该引擎类型的对象
    //Engine e(s);          使用整数值s作为种子
    //e.seed(s)             使用种子s重置引擎状态
    //e.min()               此引擎可生成的最大最小值
    //e.max()
    //Engine::result_type   此引擎生成的类型
    //e.discard(u)          将引擎推进u步，u为unsigned long long

    //引擎和均布的组合==随机数发生器
    uniform_int_distribution<unsigned> u(0, 9);         //均匀分布unsigned值
    default_random_engine e2;
    for (size_t i = 0; i < 10; ++i)
    {
        cout << u(e2) << " " ;
    }
    cout << endl;

    //一个给定的随机数发生器会生器会一直生成相同随机数序列。解决：1、声明static；2、使用随机数种子time(0)
    auto r1 = good_value();
    auto r2 = good_value();
    if (r1 != r2)
        cout << "R1 != R2" << endl;
    default_random_engine e3(time(0));          //time以秒计时，适用于生成种子时间间隔大于秒级！

    //生成随机实数
    uniform_real_distribution<double> rd(0, 1);
    for (size_t i = 0; i < 10; ++i)
    {
        cout << rd(e3) << " ";
    }
    //生成非均匀分布的随机数，以正态分布为例
    normal_distribution<> n(4, 1.5);
    vector<unsigned> vals(9);
    for (size_t i = 0; i != 200; ++i)
    {
        unsigned v = lround(n(e));      //lround四舍五入到最接近的整数！，统计0～8的个数！
        if (v < vals.size())
            ++vals[v];
    }
    for (size_t j = 0; j != vals.size(); ++j)
    {
        cout << j << ": " << string(vals[j], '*') << endl;
    }
    //生成bool值
    bernoulli_distribution bb(0.8);     //增加true的胜率！0.8！
    bool b_one = bb(e3);
    if (b_one)
        cout << "One!" << endl;

    //IO未看！

    system("pause");
    return 0;
}