//定义和初始化

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<size_t,size_t,size_t> threeD2{1,2,3};

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

//成员的访问

auto book=get<0>(item);  //返回第一个成员

//细节信息访问

typedef decltype(item) trans;  // trans 是item的类型

//返回trans类型对象中成员的数量

size_t sz=tuple_size<trans>::value; //返回3

//获取第二个成员的类型

tuple_element<1,trans>::type cnt=get<1>(item);  // cnt 是一个int

bit<32> bitvec(1U);  // 32位；低位为1，其他位为0

// bitvec1初始值小；初始值中的高位被丢弃

bitset<13> bitvec1(0xbeef);  // 二进制位序列为 1111011101111

//比初始值大；高位被置为0

bitset<20> bitvec2(0xbeef); // 二进制位序列为 0000101111011101111

//64 位机中， long long 0ULL 是64个0比特，因此～0ULL是64个1

bitset<128> bitvec3(~0ULL); // 0~63 位为1; 63~127位为0

//string 初始化 bitset

bitset<32> bitvec4("1100"); //2、3 两位为1，剩余两位为0；高位被置为0。

string str("1111111000000011001101");

bitset<32> bitvec5(str,5,4); // 从str[5]开始的四个二进制位，1100

bitset<32> bitvec6(str,str.size()-4); //使用最后四个字符

unsigned long ulong=bitvec3.to_ulong();

cout<<"ulong ="<<ulong<<endl;

bitset<16> bits;
cin>> bits;  // 从cin读取最多16个0或1

cout<<"bits: "<<bits<<endl; //打印刚刚读取的内容

//查找不在字符c之后的字符串ei

string pattern("[^c]ei");
//包含pattern的整个单词

pattern="[[\:alpha\:]]*"+pattern+"[[\:alpha\:]]*";
regex r(pattern); //构造一个用于查找模式的regex

smatch result;  //定义一个对象保存搜索结果

//定义一个string保存于模式匹配和不匹配的文本

string test_str="receipt freind theif receive";

//查找匹配的字符串

if(regex_search(test_str,result,r)){
    std::cout<<result.str()<<endl; //打印匹配的单词

}

// regex_match example

#include <iostream>
#include <string>
#include <regex>

int main ()
{


    if (std::regex_match ("subject", std::regex("(sub)(.*)") ))
        std::cout << "string literal matched\n";

    const char cstr[] = "subject";
    std::string s ("subject");
    std::regex e ("(sub)(.*)");

    if (std::regex_match (s,e))
        std::cout << "string object matched\n";

    if ( std::regex_match ( s.begin(), s.end(), e ) )
        std::cout << "range matched\n";

    std::cmatch cm;    // same as std::match_results<const char*> cm;
    
    std::regex_match (cstr,cm,e);
    std::cout << "string literal with " << cm.size() << " matches\n";

    std::smatch sm;    // same as std::match_results<string::const_iterator> sm;
    std::regex_match (s,sm,e);
    std::cout << "string object with " << sm.size() << " matches\n";

    std::regex_match ( s.cbegin(), s.cend(), sm, e);
    std::cout << "range with " << sm.size() << " matches\n";
    // using explicit flags:

    std::regex_match ( cstr, cm, e, std::regex_constants::match_default );

    std::cout << "the matches were: ";
    for (unsigned i=0; i<cm.size(); ++i) {
        std::cout << "[" << cm[i] << "] ";
    }

    std::cout << std::endl;

    return 0;
}

/*

result:

string literal matched
string object matched
range matched
string literal with 3 matches
string object with 3 matches
range with 3 matches
the matches were: [subject] [sub] [ject]


 */ 

"(\()?(\d{3})(\))?([-. ])?(\d{3})([-. ]?)(\d{4})";

string phone="(\()?(\d{3})(\))?([-. ])?(\d{3})([-. ]?)(\d{4})";

regex r(phone); // regex对象，用于查找我们的模式

smatch m;
string s;

//从文件中读取每条记录
while (getline(cin,s)){
    //对每个匹配的电话号码
    
    for(sregex_iterator it(s.begin(),s.end(),r),end_it;it!=end_it;++it){
        //检查号码的格式是否合法
        
        if(valid(*it)){
            std::cout<<"valid:"<<it->str()<<endl;
        }else{
            cout<<"not valid:"<< it->str()<<endl;
        }
    }

}

// regex_replace example
#include <iostream>
#include <string>
#include <regex>
#include <iterator>

int main ()
{
  std::string s ("there is a subsequence in the string\n");
  std::regex e ("\b(sub)([^ ]*)");   // matches words beginning by "sub"
  // using string/c-string (3) version:

  std::cout << std::regex_replace (s,e,"sub-$2");
  // using range/c-string (6) version:
 
  std::string result;
  std::regex_replace (std::back_inserter(result), s.begin(), s.end(), e, "$2");
  std::cout << result;
  // with flags:
  
  std::cout << std::regex_replace (s,e,"$1 and $2",std::regex_constants::format_no_copy);
  std::cout << std::endl;

  return 0;
}
/*

result :
there is a sub-sequence in the string
there is a sequence in the string
sub and sequence

 */

string fmt="$2.$5.$7"; //将号码格式改为 ddd.ddd.dddd

regex r(phone);  //用来寻找模式的regex对象

string number="(908) 555-1800";
cout<<regex_replace(number,r,fmt)<<endl;

vector<unsigned> good_randVec()
{
    //定义为static的，从而每次调用都生成新的数
    
    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;
}

default_random_engine e1; //使用默认的种子

default_random_engine e2(2147483646); //使用给定的种子值

default_random_engine e3;  
e3.seed(32767);
default_random_engine e4(32767);  //e3和e4种子相同将会产生相同的随机数。

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

default_random_engine e; //生成无符号的随机数

uniform_real_distribution<double> u(0,1); // 0到1(包含)的均匀分布

for(size_t i=0;i<10;++i){
    cout<<u(e)<<"";
}

cout<<"default bool values: "<<true<<" "<<false
    <<"\nalpha bool values: "<<boolalpha
    <<true<<" "<< false<<endl;
/*

result:
default bool values: 1 0
alpha bool value: true false


*/

cout<<showbase;  //打印的时候显示进制

cout<<"default: "<<20<<" "<<1024<<endl;
cout<<"octal: "<<oct<<20<<" "<<1024<<endl;
cout<<"hex: "<<hex<<20<<" "<<1024<<endl;
cout<<"decimal: "<<dec<<20<<" "<<1024<<endl;

cout<<noshowbase; //恢复流状态
/*

default: 20 1024
octal: 024 2000
hex: 0x14 0x400
decimal: 20 1024

 */

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

//检测是否达到文件尾部

int ch; //使用一个int,而不是一个char来保存get()的返回值

//循环读取并输出输入中的所有数据

while((ch==cin.get())!=EOF){
    cout.put(ch);
}

#include <iostream>
#include <fstream>
using namespace std;

int main(){
    //以读写方式打开文档
    
    fstream inOut("copyout",fstream::ate|fstream::in|fstream::out);

    if(!inOut){
        cerr<<"Unable to open file"<<endl;
        return 0;
    }
    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); // 将写标记移动到问价尾

        inOut<<cnt;   //输出累计长度

        if(mark!=end_mark){
            inOut<<" ";
        }
        inOut.seekp(0,fstream::end); //定位到文件尾
    }

    inOut<<"\n";  //文件尾部输出换行符
    return 0;

}