auto t = tuple<int, int, int>{10, 20, 30};

auto t = tuple<string, vector<string>, pair<string, int> >

#include <iostream>

#include <tuple>

#include <string>

#include <vector>

#include <algorithm>

#include <utility>

#include <numeric>

#include "ex_17_4_SalesData.h"

using namespace std;

//matches 有三个成员：1. 一个书店的索引。2. 指向书店中元素的迭代器。3. 指向书店中元素的迭代器。

typedef tuple<vector<Sales_data>::size_type,

              vector<Sales_data>::const_iterator,

              vector<Sales_data>::const_iterator>

    matches;

//files 保存每家书店的销售记录

//findBook 返回一个 vector，每家销售了给定书籍的书店在其中都有一项

vector<matches> findBook(const vector<vector<Sales_data>> &files,

                         const string &book)

{

    vector<matches> ret; // 初始化为空 vector

    // 对每家书店，查找给定书籍匹配的记录范围

    for (auto it = files.cbegin; it != files.cend(); ++it)

    {

        // 查找具有相同 ISBN 的 Sales_data 范围，found 是一个迭代器 pair

        auto found = equal_range(it->cbegin(), it->cend(), book, compareIsbn);

        if (found.first != found.second)  // 此书店销售了给定书籍

            // 记住此书店的索引及匹配的范围

            ret.push_back(make_tuple(it - files.cbegin(), found.first, found.second));

    }

    return ret; // 如果未找到匹配记录，ret 为空

}

void reportResults(istream &in, ostream &os,

                       const vector<vector<Sales_data> > &files){

    string s;  // 要查找的书

    while (in >> s){

        auto trans = findBook(files, s);

        if (trans.empty()){

            cout << s << " not found in any stores" << endl;

            continue;  // 获得下一本要查找的书

        }

        for (const auto &store : trans)  // 对每家销售了给定书籍的书店

            //get<n > 返回 store 中 tuple 的指定的成员

            os << "store " << get<0>(store) << " sales: "

               << accumulate(get<1>(store), get<2>(store), Sales_data(s))

               << endl;

    }

}

int main(){

    return 0;

}

typedef std::pair<std::vector<Sales_data>::size_type,

                  std::pair<std::vector<Sales_data>::const_iterator,

                            std::vector<Sales_data>::const_iterator>>

                                                                      matches_pair;

std::vector<matches_pair>

findBook_pair(const std::vector<std::vector<Sales_data> > &files,

              const std::string &book)

{

    std::vector<matches_pair> ret;

    for(auto it = files.cbegin(); it != files.cend(); ++it)

    {

        auto found = std::equal_range(it->cbegin(), it->cend(), book, compareIsbn);

        if(found.first != found.second)

            ret.push_back(std::make_pair(it - files.cbegin(),

                                         std::make_pair(found.first, found.second)));

    }

    return ret;

}

struct matches_struct

{

    std::vector<Sales_data>::size_type st;

    std::vector<Sales_data>::const_iterator first;

    std::vector<Sales_data>::const_iterator last;

    matches_struct(std::vector<Sales_data>::size_type s,

                   std::vector<Sales_data>::const_iterator f,

                   std::vector<Sales_data>::const_iterator l) : st(s), first(f), last(l) { }

} ;

std::vector<matches_struct>

findBook_struct(const std::vector<std::vector<Sales_data> > &files,

                const std::string &book)

{

    std::vector<matches_struct> ret;

    for(auto it = files.cbegin(); it != files.cend(); ++it)

    {

        auto found = std::equal_range(it->cbegin(), it->cend(), book, compareIsbn);

        if(found.first != found.second)

            ret.push_back(matches_struct(it - files.cbegin(), found.first, found.second));

    }

    return ret;

}

(a) bitset<64> bitvec(32);

// 0000000000000000000000000000000000000000000000000000000000100000

(b) bitset<32> bv(1010101);

// 00000000000011110110100110110101

(c) string bstr; cin >> bstr; bitset<8> bv(bstr);

// 根据输入的 str 转换成 bitset

#include <iostream>

#include <bitset>

#include <vector>

int main()

{

    std::vector<int> v = { 1, 2, 3, 5, 8, 13, 21 };

    std::bitset<32> bset;

    for (auto i : v)    bset.set(i);

    std::bitset<32> bset2;

    for (unsigned i = 0; i != 32; ++i)

        bset2[i] = bset[i];

    std::cout <<bset <<std::endl;

    std::cout <<bset2<<std::endl;

}

#include <iostream>

#include <bitset>

#include <utility>

#include <string>

#include <iostream>

//class Quiz

template<std::size_t N>

class Quiz

{

public:

    //constructors

    Quiz() = default;

    Quiz(std::string& s) :bitquiz(s){ }

    //generate grade

    template<std::size_t M>

    friend std::size_t grade(Quiz<M> const&, Quiz<M> const&);

    //print

    template<std::size_t M>

    friend std::ostream& operator<<(std::ostream&, Quiz<M> const&);

    //update bitset

    void update(std::pair<std::size_t, bool>);

private:

    std::bitset<N> bitquiz;

};

#endif

template<std::size_t N>

void Quiz<N>::update(std::pair<std::size_t, bool> pair)

{

    bitquiz.set(pair.first, pair.second);

}

template<std::size_t M>

std::ostream& operator<<(std::ostream& os, Quiz<M> const& quiz)

{

    os << quiz.bitquiz;

    return os;

}

template<std::size_t M>

std::size_t grade(Quiz<M> const& corAns, Quiz<M> const& stuAns)

{

    auto result = stuAns.bitquiz ^ corAns.bitquiz;

    result.flip();

    return result.count();

}

int main()

{

    //Ex17_11

    std::string s = "1010101";

    Quiz<10> quiz(s);

    std::cout << quiz << std::endl;

    //EX17_12

    quiz.update(std::make_pair(1, true));

    std::cout << quiz << std::endl;

    //Ex17_13

    std::string answer = "10011";

    std::string stu_answer = "11001";

    Quiz<5> ans(answer), stu_ans(stu_answer);

    std::cout << grade(ans, stu_ans) << std::endl;

    return 0;

}

// 将字符串 file 中所有匹配模式 r 的子串输出

for (sregex_iterator it(file.begin(), file.end(), r), end_it; it != end_it; ++it){

    cout << it ->str() << endl;

}

if (regex_search(filename, results, r))

    cout << results.str(1) << endl;  //.str (1) 获取第一个子表达式匹配结果

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

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

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

string number = "(908) 555-1800";

cout << regex_replace(number, r, fmt) << endl;

#include <iostream>

using std::cout;

using std::cin;

using std::endl;

#include <string>

using std::string;

#include <regex>

using std::regex;

using std::regex_error;

int main()

{

    // for ex17.14

    // error_brack

    try{

        regex r("[[:alnum:]+\\.(cpp|cxx|cc)$", regex::icase);

    }

    catch(regex_error e)

    {

        cout << e.what() << " code: " << e.code() << endl;

    }

    // for ex17.15

    regex r("[[:alpha:]]*[^c]ei[[:alpha:]]*", regex::icase);

    string s;

    cout << "Please input a word! Input 'q' to quit!" << endl;

    while(cin >> s && s != "q")

    {

        if(std::regex_match(s, r))

            cout << "Input word " << s << " is okay!" << endl;

        else

            cout << "Input word " << s << " is not okay!" <<endl;

        cout << "Please input a word! Input 'q' to quit!" << endl;

    }

    cout << endl;

    // for ex17.16

    r.assign("[^c]ei", regex::icase);

    cout << "Please input a word! Input 'q' to quit!" << endl;

    while(cin >> s && s != "q")

    {

        if(std::regex_match(s, r))

            cout << "Input word " << s << " is okay!" << endl;

        else

            cout << "Input word " << s << " is not okay!" <<endl;

        cout << "Please input a word! Input 'q' to quit!" << endl;

    }

    return 0;

}

#include <iostream>

using std::cout;

using std::cin;

using std::endl;

#include <string>

using std::string;

#include <regex>

using std::regex;

using std::sregex_iterator;

int main()

{

	string s;

	cout << "Please input a sequence of words:" << endl;

	getline(cin, s);

	cout << endl;

	cout << "Word(s) that violiate the \"ei\" grammar rule:" << endl;

	string pattern("[^c]ei");

	pattern = "[[:alpha:]]*" + pattern + "[[:alpha:]]*";

	regex r(pattern, regex::icase);

	for (sregex_iterator it(s.begin(), s.end(), r), end_it; it != end_it; ++it)

		cout << it->str() << endl;

	return 0;

}

#include <iostream>

using std::cout;

using std::cin;

using std::endl;

#include <string>

using std::string;

#include <regex>

using std::regex;

using std::sregex_iterator;

using std::smatch;

bool valid(const smatch& m);

int main()

{

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

	regex r(phone);

	smatch m;

	string s;

	bool valid_record;

	// read each record from the input file

	while (getline(cin, s))

	{

		valid_record = false;

		// for each matching phone number

		for (sregex_iterator it(s.begin(), s.end(), r), end_it; it != end_it; ++it)

		{

			valid_record = true;

			// check whether the number's formatting is valid

			if (valid(*it))

				cout << "valid phone number: " << it->str() << endl;

			else

				cout << "invalid phone number: " << it->str() << endl;

		}

		if (!valid_record)

			cout << "invalid record!" << endl;

	}

	return 0;

}

bool valid(const smatch& m)

{

	// if there is an open parenthesis before the area code

	if (m[1].matched)

		// the area code must be followed by a close parenthesis

		// and followed immediately by the rest of the number or a space

		return m[3].matched && (m[4].matched == 0 || m[4].str() == " ");

	else

		// then there can't be a close after the area code

		// the delimiters between the other two components must match

		return !m[3].matched && m[4].str() == m[6].str();

}

#include <iostream>

using std::cerr;

using std::cout;

using std::cin;

using std::endl;

using std::istream;

using std::ostream;

#include <fstream>

using std::ifstream;

using std::ofstream;

#include <sstream>

using std::istringstream;

using std::ostringstream;

#include <string>

using std::string;

#include <vector>

using std::vector;

#include <regex>

using std::regex;

using std::sregex_iterator;

using std::smatch;

struct PersonInfo

{

    string name;

    vector<string> phones;

};

bool valid(const smatch& m);

bool read_record(istream& is, vector<PersonInfo>& people);

void format_record(ostream& os, const vector<PersonInfo>& people);

// fake function that makes the program compile

string format(const string &num) { return num; }

int main()

{

    vector<PersonInfo> people;

    string filename;

    cout << "Please input a record file name: ";

    cin >> filename;

    cout << endl;

    ifstream fin(filename);

    if (read_record(fin, people))

    {

        ofstream fout("data\\result.txt", ofstream::trunc);

        format_record(fout, people);

    }

    else

    {

        cout << "Fail to open file " << filename << endl;

    }

    return 0;

}

bool valid(const smatch& m)

{

    // if there is an open parenthesis before the area code

    if (m[1].matched)

        // the area code must be followed by a close parenthesis

        // and followed immediately by the rest of the number or a space

        return m[3].matched && (m[4].matched == 0 || m[4].str() == " ");

    else

        // then there can't be a close after the area code

        // the delimiters between the other two components must match

        return !m[3].matched && m[4].str() == m[6].str();

}

bool read_record(istream& is, vector<PersonInfo>& people)

{

    if (is)

    {

        string line, word; // will hold a line and word from input, respectively

                           // read the input a line at a time until cin hits end-of-file (or another error)

        while (getline(is, line))

        {

            PersonInfo info; // create an object to hold this record's data

            istringstream record(line); // bind record to the line we just read

            record >> info.name; // read the name

            while (record >> word) // read the phone numbers

                info.phones.push_back(word); // and store them

            people.push_back(info); // append this record to people

        }

        return true;

    }

    else

        return false;

}

void format_record(ostream& os, const vector<PersonInfo>& people)

{

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

    regex r(phone);

    smatch m;

    for (const auto &entry : people)

    {

        // for each entry in people

        ostringstream formatted, badNums; // objects created on each loop

        for (const auto &nums : entry.phones)

        {

            for (sregex_iterator it(nums.begin(), nums.end(), r), end_it; it != end_it; ++it)

            {

                // for each number

                // check whether the number's formatting is valid

                if (!valid(*it))

                    // string in badNums

                    badNums << " " << nums;

                else

                    // "writes" to formatted's string

                    formatted << " " << format(nums);

            }

        }

        if (badNums.str().empty()) // there were no bad numbers

            os << entry.name << " " // print the name

            << formatted.str() << endl; // and reformatted numbers

        else // otherwise, print the name and bad numbers

            cerr << "input error: " << entry.name

            << " invalid number(s) " << badNums.str() << endl;

    }

}

#include <iostream>

using std::cout;

using std::cin;

using std::endl;

#include<string>

using std::string;

#include <regex>

using std::regex;

using std::sregex_iterator;

using std::smatch;

bool valid(const smatch& m);

int main()

{

	string zipcode =

		"(\\d{5})([-])?(\\d{4})?\\b";

	regex r(zipcode);

	smatch m;

	string s;

	while (getline(cin, s))

	{

		//! for each matching zipcode number

		for (sregex_iterator it(s.begin(), s.end(), r), end_it;

			it != end_it; ++it)

		{

			//! check whether the number's formatting is valid

			if (valid(*it))

				cout << "valid zipcode number: " << it->str() << endl;

			else

				cout << "invalid zipcode number: " << s << endl;

		}

	}

	return 0;

}

bool valid(const smatch& m)

{

	if ((m[2].matched)&&(!m[3].matched))

		return false;

	else

		return true;

}

#include <iostream>

#include <regex>

#include <string>

using namespace std;

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

string format = "$2.$5.$7";

regex r(pattern);

string s;

int main()

{

    while(getline(cin,s))

    {

        cout<<regex_replace(s,r,format)<<endl;

    }

    return 0;

}

#include <iostream>

#include <regex>

#include <string>

using namespace std;

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

string fmt = "$2.$5.$7";

regex r(pattern);

string s;

int main()

{

    while(getline(cin,s))

    {

        smatch result;

        regex_search(s,result,r);

        if(!result.empty())

        {

        cout<<result.prefix()<<result.format(fmt)<<endl;

        }

        else

        {

            cout<<"Sorry, No match."<<endl;

        }

    }

    return 0;

}

#include <iostream>

#include <regex>

#include <string>

using namespace std;

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

string fmt = "$1-$3";

regex r(pattern);

string s;

int main()

{

    while(getline(cin,s))

    {

        smatch result;

        regex_search(s,result, r);

        if(!result.empty())

        {

            cout<<result.format(fmt)<<endl;

        }

        else

        {

            cout<<"Sorry, No match."<<endl;

        }

    }

    return 0;

}

// 初始化分布类型

uniform_int_distribution<unsigned> u(0, 9);

// 初始化引擎

default_random_engine e;

// 随机生成 0-9 的无符号整数

cout << u(e) << endl;

#include <iostream>

#include <random>

#include<string>

// default version

unsigned random_gen();

// with seed spicified

unsigned random_gen(unsigned seed);

// with seed and range spicified

unsigned random_gen(unsigned seed, unsigned min, unsigned max);

int main()

{

    std::string temp;

    while(std::cin >> temp)

    std::cout << std::hex << random_gen(19, 1, 10) << std::endl;

    return 0;

}

unsigned random_gen()

{

    static std::default_random_engine e;

    static std::uniform_int_distribution<unsigned> ud;

    return ud(e);

}

unsigned random_gen(unsigned seed)

{

    static std::default_random_engine e(seed);

    static std::uniform_int_distribution<unsigned> ud;

    return ud(e);

}

unsigned random_gen(unsigned seed, unsigned min, unsigned max)

{

    static std::default_random_engine e(seed);

    static std::uniform_int_distribution<unsigned> ud(min, max);

    return ud(e);

}

#include <iostream>

using std::cout;

using std::endl;

#include <fstream>

using std::ifstream;

#include <string>

using std::string;

#include <vector>

using std::vector;

#include <random>

using std::default_random_engine;

using std::uniform_int_distribution;

#include <ctime>

using std::time;

#include <algorithm>

using std::sort;

using std::find_if;

#include <utility>

using std::pair;

int main() {

	typedef pair<string, string> ps;

	ifstream i("d.txt");

	vector<ps> dict;

	string str1, str2;

	// read wirds from dictionary

	while (i >> str1 >> str2) {

		dict.emplace_back(str1, str2);

	}

	i.close();

	// sort words in vector

	sort(dict.begin(), dict.end(), [](const ps &_ps1, const ps &_ps2){ return _ps1.first < _ps2.first; });

	i.open("i.txt");

	default_random_engine e(unsigned int(time(0)));

	// read words from text

	while (i >> str1) {

	  // find word in dictionary

		vector<ps>::const_iterator it = find_if(dict.cbegin(), dict.cend(),

		  [&str1](const ps &_ps){ return _ps.first == str1; });

		// if word doesn't exist in dictionary

		if (it == dict.cend()) {

		  // write it itself

			cout << str1 << ' ';

		}

		else {

		  // get random meaning of word 

			uniform_int_distribution<unsigned> u (0, find_if(dict.cbegin(), dict.cend(),

			 [&str1](const ps &_ps){ return _ps.first > str1; }) - it - 1);

			// write random meaning

			cout << (it + u(e))->second << ' ';

		}

	}

	return 0;

}

#include <iostream>

#include<iomanip>

#include <math.h>

using namespace std;

int main()

{

	cout <<"default format: " << 100 * sqrt(2.0) << '\n'

		<< "scientific: " << scientific << 100 * sqrt(2.0) << '\n'

		<< "fixed decimal: " << fixed << 100 * sqrt(2.0) << '\n'

		<< "hexidecimal: " << uppercase << hexfloat << 100 * sqrt(2.0) << '\n'

		<< "use defaults: " << defaultfloat << 100 * sqrt(2.0)

		<< "\n\n";

}

//17.36

//Modify the program from the previous exercise to print the various floating-point values so that they line up in a column.

#include <iostream>

#include<iomanip>

#include <math.h>

using namespace std;

int main()

{

	cout <<left<<setw(15) << "default format:" <<setw(25)<< right<< 100 * sqrt(2.0) << '\n'

	<< left << setw(15) << "scientific:" << scientific << setw(25) << right << 100 * sqrt(2.0) << '\n'

	<< left << setw(15) << "fixed decimal:" << setw(25) << fixed << right << 100 * sqrt(2.0) << '\n'

	<< left << setw(15) << "hexidecimal:" << setw(25) << uppercase << hexfloat << right << 100 * sqrt(2.0) << '\n'

	<< left << setw(15) << "use defaults:" << setw(25) << defaultfloat << right << 100 * sqrt(2.0)

	<< "\n\n";

}

//17.37

//Use the unformatted version of getline to read a file a line at a time.

//Test your program by giving it a file that contains empty lines as well as lines that are

//longer than the character array that you pass to getline.

#include <iostream>

#include <fstream>

#include <iomanip>

using namespace std;

//int main () {

//  ifstream myfile("F:\\Git\\Cpp-Primer\\ch17\\17_37_38\\test.txt");

//  if (myfile) cout << 1 << endl;

//  char sink [250];

//

//  while(myfile.getline(sink,250))

//  {

//    cout << sink << endl;

//  }

//  return 0;

//}

//17.38

//Extend your program from the previous exercise to print each word you read onto its own line.

//#include <iostream>

//#include <fstream>

//#include <iomanip>

//

//using namespace std;

//

//int main () {

//  ifstream myfile ("F:\\Git\\Cpp-Primer\\ch17\\17_37_38\\test.txt");

//  char sink [250];

//

//  while(myfile.getline(sink,250,' '))

//  {

//    cout << sink << endl;

//  }

//  return 0;

//}

int main()

{

	std::cout << "Standard Output!\n";

	std::cerr << "Standard Error!\n";

	std::clog << "Standard Log??\n";

}