练习17.1

定义一个保存三个int值的 tuple，并将其成员分别初始化为10、20和30。

解：

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

练习17.2

定义一个 tuple，保存一个 string、一个vector<string> 和一个 pair<string, int>。

解：

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

练习17.3

重写12.3节中的 TextQuery 程序，使用 tuple 代替 QueryResult 类。你认为哪种设计更好？为什么？

解：

程序略。

我认为tuple更方便。

练习17.4

编写并测试你自己版本的 findBook 函数。

解：

  1. #include <iostream>
  2. #include <tuple>
  3. #include <string>
  4. #include <vector>
  5. #include <algorithm>
  6. #include <utility>
  7. #include <numeric>
  9. #include "ex_17_4_SalesData.h"
  11. using namespace std;
  13. // matches有三个成员：1.一个书店的索引。2.指向书店中元素的迭代器。3.指向书店中元素的迭代器。
  14. typedef tuple<vector<Sales_data>::size_type,
  15.               vector<Sales_data>::const_iterator,
  16.               vector<Sales_data>::const_iterator>
  17.     matches;
  19. // files保存每家书店的销售记录
  20. // findBook返回一个vector，每家销售了给定书籍的书店在其中都有一项
  21. vector<matches> findBook(const vector<vector<Sales_data>> &files,
  22.                          const string &book)
  23. {
  24.     vector<matches> ret; //初始化为空vector
  25.     // 对每家书店，查找给定书籍匹配的记录范围
  26.     for (auto it = files.cbegin; it != files.cend(); ++it)
  27.     {
  28.         // 查找具有相同ISBN的Sales_data范围，found是一个迭代器pair
  29.         auto found = equal_range(it->cbegin(), it->cend(), book, compareIsbn);
  30.         if (found.first != found.second)  // 此书店销售了给定书籍
  31.             // 记住此书店的索引及匹配的范围
  32.             ret.push_back(make_tuple(it - files.cbegin(), found.first, found.second));
  33.     }
  34.     return ret; //如果未找到匹配记录，ret为空
  35. }
  37. void reportResults(istream &in, ostream &os,
  38.                        const vector<vector<Sales_data> > &files){
  39.     string s;  //要查找的书
  40.     while (in >> s){
  41.         auto trans = findBook(files, s);
  42.         if (trans.empty()){
  43.             cout << s << " not found in any stores" << endl;
  44.             continue;  // 获得下一本要查找的书
  45.         }
  46.         for (const auto &store : trans)  // 对每家销售了给定书籍的书店
  47.             // get<n>返回store中tuple的指定的成员
  48.             os << "store " << get<0>(store) << " sales: "
  49.                << accumulate(get<1>(store), get<2>(store), Sales_data(s))
  50.                << endl;
  51.     }
  52. }
  54. int main(){
  55.     return 0;
  56. }

练习17.5

重写 findBook，令其返回一个 pair，包含一个索引和一个迭代器pair。

解：

  1. typedef std::pair<std::vector<Sales_data>::size_type,
  2.                   std::pair<std::vector<Sales_data>::const_iterator,
  3.                             std::vector<Sales_data>::const_iterator>>
  4.                                                                       matches_pair;
  6. std::vector<matches_pair>
  7. findBook_pair(const std::vector<std::vector<Sales_data> > &files,
  8.               const std::string &book)
  9. {
  10.     std::vector<matches_pair> ret;
  11.     for(auto it = files.cbegin(); it != files.cend(); ++it)
  12.     {
  13.         auto found = std::equal_range(it->cbegin(), it->cend(), book, compareIsbn);
  14.         if(found.first != found.second)
  15.             ret.push_back(std::make_pair(it - files.cbegin(),
  16.                                          std::make_pair(found.first, found.second)));
  17.     }
  18.     return ret;
  19. }

练习17.6

重写 findBook，不使用tuple和pair。

解：

  1. struct matches_struct
  2. {
  3.     std::vector<Sales_data>::size_type st;
  4.     std::vector<Sales_data>::const_iterator first;
  5.     std::vector<Sales_data>::const_iterator last;
  6.     matches_struct(std::vector<Sales_data>::size_type s,
  7.                    std::vector<Sales_data>::const_iterator f,
  8.                    std::vector<Sales_data>::const_iterator l) : st(s), first(f), last(l) { }
  9. } ;
  11. std::vector<matches_struct>
  12. findBook_struct(const std::vector<std::vector<Sales_data> > &files,
  13.                 const std::string &book)
  14. {
  15.     std::vector<matches_struct> ret;
  16.     for(auto it = files.cbegin(); it != files.cend(); ++it)
  17.     {
  18.         auto found = std::equal_range(it->cbegin(), it->cend(), book, compareIsbn);
  19.         if(found.first != found.second)
  20.             ret.push_back(matches_struct(it - files.cbegin(), found.first, found.second));
  21.     }
  22.     return ret;
  23. }

练习17.7

解释你更倾向于哪个版本的findBook，为什么。

解：

使用tuple的版本。很明显更加灵活方便。

练习17.8

在本节最后一段代码中，如果我们将Sales_data()作为第三个参数传递给accumulate，会发生什么？

解：

结果是0，以为Sales_data是默认初始化的。

练习17.9

解释下列每个bitset 对象所包含的位模式：

  1. (a) bitset<64> bitvec(32);
  2. // 0000000000000000000000000000000000000000000000000000000000100000
  3. (b) bitset<32> bv(1010101);
  4. // 00000000000011110110100110110101
  5. (c) string bstr; cin >> bstr; bitset<8> bv(bstr);
  6. // 根据输入的str转换成bitset

练习17.10

使用序列1、2、3、5、8、13、21初始化一个bitset，将这些位置置位。对另一个bitset进行默认初始化，并编写一小段程序将其恰当的位置位。

解：

  1. #include <iostream>
  2. #include <bitset>
  3. #include <vector>
  5. int main()
  6. {
  7.     std::vector<int> v = { 1, 2, 3, 5, 8, 13, 21 };
  8.     std::bitset<32> bset;
  10.     for (auto i : v)    bset.set(i);
  12.     std::bitset<32> bset2;
  13.     for (unsigned i = 0; i != 32; ++i)
  14.         bset2[i] = bset[i];
  16.     std::cout <<bset <<std::endl;
  17.     std::cout <<bset2<<std::endl;
  18. }

练习17.11

定义一个数据结构，包含一个整型对象，记录一个包含10个问题的真/假测验的解答。如果测验包含100道题，你需要对数据结构做出什么改变（如果需要的话）？

解：

  1. #include <iostream>
  2. #include <bitset>
  3. #include <utility>
  4. #include <string>
  5. #include <iostream>
  7. //class Quiz
  8. template<std::size_t N>
  9. class Quiz
  10. {
  11. public:
  12.     //constructors
  13.     Quiz() = default;
  14.     Quiz(std::string& s) :bitquiz(s){ }
  16.     //generate grade
  17.     template<std::size_t M>
  18.     friend std::size_t grade(Quiz<M> const&, Quiz<M> const&);
  20.     //print
  21.     template<std::size_t M>
  22.     friend std::ostream& operator<<(std::ostream&, Quiz<M> const&);
  24.     //update bitset
  25.     void update(std::pair<std::size_t, bool>);
  26. private:
  27.     std::bitset<N> bitquiz;
  28. };
  29. #endif
  31. template<std::size_t N>
  32. void Quiz<N>::update(std::pair<std::size_t, bool> pair)
  33. {
  34.     bitquiz.set(pair.first, pair.second);
  35. }
  37. template<std::size_t M>
  38. std::ostream& operator<<(std::ostream& os, Quiz<M> const& quiz)
  39. {
  40.     os << quiz.bitquiz;
  41.     return os;
  42. }
  44. template<std::size_t M>
  45. std::size_t grade(Quiz<M> const& corAns, Quiz<M> const& stuAns)
  46. {
  47.     auto result = stuAns.bitquiz ^ corAns.bitquiz;
  48.     result.flip();
  49.     return result.count();
  50. }
  53. int main()
  54. {
  55.     //Ex17_11
  56.     std::string s = "1010101";
  57.     Quiz<10> quiz(s);
  58.     std::cout << quiz << std::endl;
  60.     //EX17_12
  61.     quiz.update(std::make_pair(1, true));
  62.     std::cout << quiz << std::endl;
  64.     //Ex17_13
  65.     std::string answer = "10011";
  66.     std::string stu_answer = "11001";
  67.     Quiz<5> ans(answer), stu_ans(stu_answer);
  68.     std::cout << grade(ans, stu_ans) << std::endl;
  70.     return 0;
  71. }

练习17.12

使用前一题中的数据结构，编写一个函数，它接受一个问题编号和一个表示真/假解答的值，函数根据这两个参数更新测验的解答。

解：

参考17.11。

练习17.13

编写一个整型对象，包含真/假测验的正确答案。使用它来为前两题中的数据结构生成测验成绩。

解：

参考17.11。

练习17.14

编写几个正则表达式，分别触发不同错误。运行你的程序，观察编译器对每个错误的输出。

解：

  1. #include <iostream>
  2. using std::cout;
  3. using std::cin;
  4. using std::endl;
  6. #include <string>
  7. using std::string;
  9. #include <regex>
  10. using std::regex;
  11. using std::regex_error;
  13. int main()
  14. {
  15.     // for ex17.14
  16.     // error_brack
  17.     try{
  18.         regex r("[[:alnum:]+\\.(cpp|cxx|cc)$", regex::icase);
  19.     }
  20.     catch(regex_error e)
  21.     {
  22.         cout << e.what() << " code: " << e.code() << endl;
  23.     }
  25.     // for ex17.15
  26.     regex r("[[:alpha:]]*[^c]ei[[:alpha:]]*", regex::icase);
  27.     string s;
  28.     cout << "Please input a word! Input 'q' to quit!" << endl;
  29.     while(cin >> s && s != "q")
  30.     {
  31.         if(std::regex_match(s, r))
  32.             cout << "Input word " << s << " is okay!" << endl;
  33.         else
  34.             cout << "Input word " << s << " is not okay!" <<endl;
  36.         cout << "Please input a word! Input 'q' to quit!" << endl;
  37.     }
  39.     cout << endl;
  41.     // for ex17.16
  42.     r.assign("[^c]ei", regex::icase);
  43.     cout << "Please input a word! Input 'q' to quit!" << endl;
  44.     while(cin >> s && s != "q")
  45.     {
  46.         if(std::regex_match(s, r))
  47.             cout << "Input word " << s << " is okay!" << endl;
  48.         else
  49.             cout << "Input word " << s << " is not okay!" <<endl;
  51.         cout << "Please input a word! Input 'q' to quit!" << endl;
  52.     }
  54.     return 0;
  55. }

练习17.15

编写程序，使用模式查找违反“i在e之前，除非在c之后”规则的单词。你的程序应该提示用户输入一个单词，然后指出此单词是否符号要求。用一些违反和未违反规则的单词测试你的程序。

解：

参考17.14。

练习17.16

如果前一题程序中的regex对象用"[^c]ei"进行初始化，将会发生什么？用此模式测试你的程序，检查你的答案是否正确。

解：

参考17.14。

练习17.17

更新你的程序，令它查找输入序列中所有违反”ei”语法规则的单词。

解：

  1. #include <iostream>
  2. using std::cout;
  3. using std::cin;
  4. using std::endl;
  6. #include <string>
  7. using std::string;
  9. #include <regex>
  10. using std::regex;
  11. using std::sregex_iterator;
  13. int main()
  14. {
  15.     string s;
  16.     cout << "Please input a sequence of words:" << endl;
  17.     getline(cin, s);
  18.     cout << endl;
  19.     cout << "Word(s) that violiate the \"ei\" grammar rule:" << endl;
  20.     string pattern("[^c]ei");
  21.     pattern = "[[:alpha:]]*" + pattern + "[[:alpha:]]*";
  22.     regex r(pattern, regex::icase);
  23.     for (sregex_iterator it(s.begin(), s.end(), r), end_it; it != end_it; ++it)
  24.         cout << it->str() << endl;
  26.     return 0;
  27. }

练习17.18

修改你的程序，忽略包含“ei`但并非拼写错误的单词，如“albeit”和“neighbor”。

解：

参考17.17。

练习17.19

为什么可以不先检查m[4]是否匹配了就直接调用m[4].str()？

解：

如果不匹配，则m[4].str()返回空字符串。

练习17.20

编写你自己版本的验证电话号码的程序。

解：

  1. #include <iostream>
  2. using std::cout;
  3. using std::cin;
  4. using std::endl;
  6. #include <string>
  7. using std::string;
  9. #include <regex>
  10. using std::regex;
  11. using std::sregex_iterator;
  12. using std::smatch;
  14. bool valid(const smatch& m);
  16. int main()
  17. {
  18.     string phone = "(\\()?(\\d{ 3 })(\\))?([-. ])?(\\d{ 3 })([-. ]?)(\\d{ 4 })";
  19.     regex r(phone);
  20.     smatch m;
  21.     string s;
  22.     bool valid_record;
  23.     // read each record from the input file
  24.     while (getline(cin, s))
  25.     {
  26.         valid_record = false;
  27.         // for each matching phone number
  28.         for (sregex_iterator it(s.begin(), s.end(), r), end_it; it != end_it; ++it)
  29.         {
  30.             valid_record = true;
  31.             // check whether the number's formatting is valid
  32.             if (valid(*it))
  33.                 cout << "valid phone number: " << it->str() << endl;
  34.             else
  35.                 cout << "invalid phone number: " << it->str() << endl;
  36.         }
  38.         if (!valid_record)
  39.             cout << "invalid record!" << endl;
  40.     }
  41.     return 0;
  42. }
  44. bool valid(const smatch& m)
  45. {
  46.     // if there is an open parenthesis before the area code
  47.     if (m[1].matched)
  48.         // the area code must be followed by a close parenthesis
  49.         // and followed immediately by the rest of the number or a space
  50.         return m[3].matched && (m[4].matched == 0 || m[4].str() == " ");
  51.     else
  52.         // then there can't be a close after the area code
  53.         // the delimiters between the other two components must match
  54.         return !m[3].matched && m[4].str() == m[6].str();
  55. }

练习17.21

使用本节定义的valid 函数重写8.3.2节中的电话号码程序。

解：

  1. #include <iostream>
  2. using std::cerr;
  3. using std::cout;
  4. using std::cin;
  5. using std::endl;
  6. using std::istream;
  7. using std::ostream;
  9. #include <fstream>
  10. using std::ifstream;
  11. using std::ofstream;
  13. #include <sstream>
  14. using std::istringstream;
  15. using std::ostringstream;
  17. #include <string>
  18. using std::string;
  20. #include <vector>
  21. using std::vector;
  23. #include <regex>
  24. using std::regex;
  25. using std::sregex_iterator;
  26. using std::smatch;
  28. struct PersonInfo
  29. {
  30.     string name;
  31.     vector<string> phones;
  32. };
  34. bool valid(const smatch& m);
  35. bool read_record(istream& is, vector<PersonInfo>& people);
  36. void format_record(ostream& os, const vector<PersonInfo>& people);
  38. // fake function that makes the program compile
  39. string format(const string &num) { return num; }
  41. int main()
  42. {
  43.     vector<PersonInfo> people;
  45.     string filename;
  46.     cout << "Please input a record file name: ";
  47.     cin >> filename;
  48.     cout << endl;
  49.     ifstream fin(filename);
  51.     if (read_record(fin, people))
  52.     {
  53.         ofstream fout("data\\result.txt", ofstream::trunc);
  54.         format_record(fout, people);
  55.     }
  56.     else
  57.     {
  58.         cout << "Fail to open file " << filename << endl;
  59.     }
  61.     return 0;
  62. }
  64. bool valid(const smatch& m)
  65. {
  66.     // if there is an open parenthesis before the area code
  67.     if (m[1].matched)
  68.         // the area code must be followed by a close parenthesis
  69.         // and followed immediately by the rest of the number or a space
  70.         return m[3].matched && (m[4].matched == 0 || m[4].str() == " ");
  71.     else
  72.         // then there can't be a close after the area code
  73.         // the delimiters between the other two components must match
  74.         return !m[3].matched && m[4].str() == m[6].str();
  75. }
  77. bool read_record(istream& is, vector<PersonInfo>& people)
  78. {
  79.     if (is)
  80.     {
  81.         string line, word; // will hold a line and word from input, respectively
  82.                            // read the input a line at a time until cin hits end-of-file (or another error)
  83.         while (getline(is, line))
  84.         {
  85.             PersonInfo info; // create an object to hold this record's data
  86.             istringstream record(line); // bind record to the line we just read
  87.             record >> info.name; // read the name
  88.             while (record >> word) // read the phone numbers
  89.                 info.phones.push_back(word); // and store them
  90.             people.push_back(info); // append this record to people
  91.         }
  92.         return true;
  93.     }
  94.     else
  95.         return false;
  96. }
  98. void format_record(ostream& os, const vector<PersonInfo>& people)
  99. {
  100.     string phone = "(\\()?(\\d{ 3 })(\\))?([-. ])?(\\d{ 3 })([-. ]?)(\\d{ 4 })";
  101.     regex r(phone);
  102.     smatch m;
  104.     for (const auto &entry : people)
  105.     {
  106.         // for each entry in people
  107.         ostringstream formatted, badNums; // objects created on each loop
  108.         for (const auto &nums : entry.phones)
  109.         {
  110.             for (sregex_iterator it(nums.begin(), nums.end(), r), end_it; it != end_it; ++it)
  111.             {
  112.                 // for each number
  113.                 // check whether the number's formatting is valid
  114.                 if (!valid(*it))
  115.                     // string in badNums
  116.                     badNums << " " << nums;
  117.                 else
  118.                     // "writes" to formatted's string
  119.                     formatted << " " << format(nums);
  120.             }
  121.         }
  123.         if (badNums.str().empty()) // there were no bad numbers
  124.             os << entry.name << " " // print the name
  125.             << formatted.str() << endl; // and reformatted numbers
  126.         else // otherwise, print the name and bad numbers
  127.             cerr << "input error: " << entry.name
  128.             << " invalid number(s) " << badNums.str() << endl;
  129.     }
  130. }

练习17.22

重写你的电话号码程序，使之允许在号码的三个部分之间放置任意多个空白符。

解：

参考17.21。

练习17.23

编写查找邮政编码的正则表达式。一个美国邮政编码可以由五位或九位数字组成。前五位数字和后四位数字之间可以用一个短横线分隔。

解：

  1. #include <iostream>
  2. using std::cout;
  3. using std::cin;
  4. using std::endl;
  6. #include<string>
  7. using std::string;
  9. #include <regex>
  10. using std::regex;
  11. using std::sregex_iterator;
  12. using std::smatch;
  14. bool valid(const smatch& m);
  16. int main()
  17. {
  18.     string zipcode =
  19.         "(\\d{5})([-])?(\\d{4})?\\b";
  20.     regex r(zipcode);
  21.     smatch m;
  22.     string s;
  24.     while (getline(cin, s))
  25.     {
  27.         //! for each matching zipcode number
  28.         for (sregex_iterator it(s.begin(), s.end(), r), end_it;
  29.             it != end_it; ++it)
  30.         {
  31.             //! check whether the number's formatting is valid
  32.             if (valid(*it))
  33.                 cout << "valid zipcode number: " << it->str() << endl;
  34.             else
  35.                 cout << "invalid zipcode number: " << s << endl;
  36.         }
  38.     }
  39.     return 0;
  40. }
  42. bool valid(const smatch& m)
  43. {
  45.     if ((m[2].matched)&&(!m[3].matched))
  46.         return false;
  47.     else
  48.         return true;
  49. }

练习17.24

编写你自己版本的重拍电话号码格式的程序。

解：

  1. #include <iostream>
  2. #include <regex>
  3. #include <string>
  5. using namespace std;
  8. string pattern = "(\\()?(\\d{3})(\\))?([-. ])?(\\d{3})([-. ])?(\\d{4})";
  9. string format = "$2.$5.$7";
  10. regex r(pattern);
  11. string s;
  13. int main()
  14. {
  15.     while(getline(cin,s))
  16.     {
  17.         cout<<regex_replace(s,r,format)<<endl;
  18.     }
  20.     return 0;
  21. }

练习17.25

重写你的电话号码程序，使之只输出每个人的第一个电话号码。

解：

  1. #include <iostream>
  2. #include <regex>
  3. #include <string>
  5. using namespace std;
  7. string pattern = "(\\()?(\\d{3})(\\))?([-. ])?(\\d{3})([-. ])?(\\d{4})";
  8. string fmt = "$2.$5.$7";
  9. regex r(pattern);
  10. string s;
  12. int main()
  13. {
  14.     while(getline(cin,s))
  15.     {
  16.         smatch result;
  17.         regex_search(s,result,r);
  18.         if(!result.empty())
  19.         {
  20.         cout<<result.prefix()<<result.format(fmt)<<endl;
  21.         }
  22.         else
  23.         {
  24.             cout<<"Sorry, No match."<<endl;
  25.         }
  26.     }
  28.     return 0;
  29. }

练习17.26

重写你的电话号码程序，使之对多于一个电话号码的人只输出第二个和后续号码。

解：

略

练习17.27

编写程序，将九位数字邮政编码的格式转换为 ddddd-dddd。

解：

  1. #include <iostream>
  2. #include <regex>
  3. #include <string>
  5. using namespace std;
  7. string pattern = "(\\d{5})([.- ])?(\\d{4})";
  8. string fmt = "$1-$3";
  10. regex r(pattern);
  11. string s;
  14. int main()
  15. {
  16.     while(getline(cin,s))
  17.     {
  18.         smatch result;
  19.         regex_search(s,result, r);
  21.         if(!result.empty())
  22.         {
  23.             cout<<result.format(fmt)<<endl;
  24.         }
  25.         else
  26.         {
  27.             cout<<"Sorry, No match."<<endl;
  28.         }
  30.     }
  31.     return 0;
  32. }

练习17.28

编写函数，每次调用生成并返回一个均匀分布的随机unsigned int。

解：

  1. #include <iostream>
  2. #include <random>
  3. #include<string>
  5. // default version
  6. unsigned random_gen();
  7. // with seed spicified
  8. unsigned random_gen(unsigned seed);
  9. // with seed and range spicified
  10. unsigned random_gen(unsigned seed, unsigned min, unsigned max);
  11. int main()
  12. {
  13.     std::string temp;
  14.     while(std::cin >> temp)
  15.     std::cout << std::hex << random_gen(19, 1, 10) << std::endl;
  16.     return 0;
  17. }
  19. unsigned random_gen()
  20. {
  21.     static std::default_random_engine e;
  22.     static std::uniform_int_distribution<unsigned> ud;
  23.     return ud(e);
  24. }
  26. unsigned random_gen(unsigned seed)
  27. {
  28.     static std::default_random_engine e(seed);
  29.     static std::uniform_int_distribution<unsigned> ud;
  30.     return ud(e);
  31. }
  33. unsigned random_gen(unsigned seed, unsigned min, unsigned max)
  34. {
  35.     static std::default_random_engine e(seed);
  36.     static std::uniform_int_distribution<unsigned> ud(min, max);
  37.     return ud(e);
  38. }

练习17.29

修改上一题中编写的函数，允许用户提供一个种子作为可选参数。

解：

参考17.28。

练习17.30

再次修改你的程序，此次增加两个参数，表示函数允许返回的最小值和最大值。

解：

参考17.28。

练习17.31

对于本节中的游戏程序，如果在do循环内定义b和e，会发生什么？

解：

由于引擎返回相同的随机数序列，因此眉不循环都会创建新的引擎，眉不循环都会生成相同的值。

练习17.32

如果我们在循环内定义resp，会发生什么？

解：

会报错，while条件中用到了resp。

练习17.33

修改11.3.6节中的单词转换程序，允许对一个给定单词有多种转换方式，每次随机选择一种进行实际转换。

解：

  1. #include <iostream>
  2. using std::cout;
  3. using std::endl;
  5. #include <fstream>
  6. using std::ifstream;
  8. #include <string>
  9. using std::string;
  11. #include <vector>
  12. using std::vector;
  14. #include <random>
  15. using std::default_random_engine;
  16. using std::uniform_int_distribution;
  18. #include <ctime>
  19. using std::time;
  21. #include <algorithm>
  22. using std::sort;
  23. using std::find_if;
  25. #include <utility>
  26. using std::pair;
  29. int main() {
  30.     typedef pair<string, string> ps;
  31.     ifstream i("d.txt");
  32.     vector<ps> dict;
  33.     string str1, str2;
  34.     // read wirds from dictionary
  35.     while (i >> str1 >> str2) {
  36.         dict.emplace_back(str1, str2);
  37.     }
  38.     i.close();
  39.     // sort words in vector
  40.     sort(dict.begin(), dict.end(), [](const ps &_ps1, const ps &_ps2){ return _ps1.first < _ps2.first; });
  41.     i.open("i.txt");
  42.     default_random_engine e(unsigned int(time(0)));
  43.     // read words from text
  44.     while (i >> str1) {
  45.       // find word in dictionary
  46.         vector<ps>::const_iterator it = find_if(dict.cbegin(), dict.cend(),
  47.           [&str1](const ps &_ps){ return _ps.first == str1; });
  48.         // if word doesn't exist in dictionary
  49.         if (it == dict.cend()) {
  50.           // write it itself
  51.             cout << str1 << ' ';
  52.         }
  53.         else {
  54.           // get random meaning of word 
  55.             uniform_int_distribution<unsigned> u (0, find_if(dict.cbegin(), dict.cend(),
  56.              [&str1](const ps &_ps){ return _ps.first > str1; }) - it - 1);
  57.             // write random meaning
  58.             cout << (it + u(e))->second << ' ';
  59.         }
  60.     }
  62.     return 0;
  63. }

练习17.34

编写一个程序，展示如何使用表17.17和表17.18中的每个操作符。

解：

略

练习17.35

修改第670页中的程序，打印2的平方根，但这次打印十六进制数字的大写形式。

解：

  2. #include <iostream>
  3. #include<iomanip>
  4. #include <math.h>
  5. using namespace std;
  7. int main()
  8. {
  9.     cout <<"default format: " << 100 * sqrt(2.0) << '\n'
  10.         << "scientific: " << scientific << 100 * sqrt(2.0) << '\n'
  11.         << "fixed decimal: " << fixed << 100 * sqrt(2.0) << '\n'
  12.         << "hexidecimal: " << uppercase << hexfloat << 100 * sqrt(2.0) << '\n'
  13.         << "use defaults: " << defaultfloat << 100 * sqrt(2.0)
  14.         << "\n\n";
  15. }
  17. //17.36
  18. //Modify the program from the previous exercise to print the various floating-point values so that they line up in a column.
  19. #include <iostream>
  20. #include<iomanip>
  21. #include <math.h>
  22. using namespace std;
  24. int main()
  25. {
  26.     cout <<left<<setw(15) << "default format:" <<setw(25)<< right<< 100 * sqrt(2.0) << '\n'
  27.     << left << setw(15) << "scientific:" << scientific << setw(25) << right << 100 * sqrt(2.0) << '\n'
  28.     << left << setw(15) << "fixed decimal:" << setw(25) << fixed << right << 100 * sqrt(2.0) << '\n'
  29.     << left << setw(15) << "hexidecimal:" << setw(25) << uppercase << hexfloat << right << 100 * sqrt(2.0) << '\n'
  30.     << left << setw(15) << "use defaults:" << setw(25) << defaultfloat << right << 100 * sqrt(2.0)
  31.     << "\n\n";
  32. }

练习17.36

修改上一题中的程序，打印不同的浮点数，使它们排成一列。

解：

参考17.36。

练习17.37

用未格式化版本的getline 逐行读取一个文件。测试你的程序，给定一个文件，既包含空行又包含长度超过你传递给geiline的字符数组大小的行。

解：

  1. //17.37
  2. //Use the unformatted version of getline to read a file a line at a time.
  3. //Test your program by giving it a file that contains empty lines as well as lines that are
  4. //longer than the character array that you pass to getline.
  6. #include <iostream>
  7. #include <fstream>
  8. #include <iomanip>
  10. using namespace std;
  12. //int main () {
  13. //  ifstream myfile("F:\\Git\\Cpp-Primer\\ch17\\17_37_38\\test.txt");
  14. //  if (myfile) cout << 1 << endl;
  15. //  char sink [250];
  16. //
  17. //  while(myfile.getline(sink,250))
  18. //  {
  19. //    cout << sink << endl;
  20. //  }
  21. //  return 0;
  22. //}
  24. //17.38
  25. //Extend your program from the previous exercise to print each word you read onto its own line.
  27. //#include <iostream>
  28. //#include <fstream>
  29. //#include <iomanip>
  30. //
  31. //using namespace std;
  32. //
  33. //int main () {
  34. //  ifstream myfile ("F:\\Git\\Cpp-Primer\\ch17\\17_37_38\\test.txt");
  35. //  char sink [250];
  36. //
  37. //  while(myfile.getline(sink,250,' '))
  38. //  {
  39. //    cout << sink << endl;
  40. //  }
  41. //  return 0;
  42. //}
  45. int main()
  46. {
  47.     std::cout << "Standard Output!\n";
  48.     std::cerr << "Standard Error!\n";
  49.     std::clog << "Standard Log??\n";
  50. }

练习17.38

扩展上一题中你的程序，将读入的每个单词打印到它所在的行。

解：

参考17.37。

练习17.39

对本节给出的 seek程序，编写你自己的版本。

解：

略