• C++ Primer第5版 习题答案 第十二章

    目录

    第十二章 动态内存

    12.1 动态内存与智能指针

    12.1.1 shared_ptr类（12.1 ~ 12.5）

    12.1.2 直接管理内存（12.6 ~ 12.9）

    12.1.3 shared_ptr和new结合使用（12.10 ~ 12.13）

    12.1.4 智能指针和异常（12.14 ~ 12.15）

    12.1.5 unique_ptr（12.16 ~ 12.18）

    12.1.6 weak_ptr（12.19 ~ 12.22）

    12.2 动态数组

    12.2.1 new和数组（12.23 ~ 12.25）

    12.2.2 allocator（12.26）

    12.3 使用标准库：文本查询程序

    12.3.1 文本查询程序设计（12.27 ~ 12.29）

    12.3.2 文本查询程序类的定义（12.30 ~ 12.33）

    工作的间隙看的，所以输出比较慢，希望能巩固基础，再往后深入。

    一直有参考这位同学的blog的答案：C++Primer第五版——习题答案+详解(完整版)_MISAYAONE的博客-CSDN博客，不过好像这位同学看的很快有很一些些不是很正确，看评论也有都一一修正(收费了，又找了这个：安月月 - 博客园，又顺藤摸瓜找到了这个：GitHub - Mooophy/Cpp-Primer: C++ Primer 5 answers，YYDS~)。

    这个答案也是自己看书然后输出的，也可能有问题，如果有发现什么问题，欢迎评论一起讨论！！

    默认大家都有了第5版的纸质书或电子书，这里就只记录题号和答案（其实对原书的截图有点侵犯版权的感觉，狗头保命）

    第十二章 动态内存

    12.1 动态内存与智能指针

    12.1.1 shared_ptr类（12.1 ~ 12.5）

    12.1：

    b1和b2都包含4个元素。

    12.2：

    1. string& StrBlob::front() const {
    2.     check(0, "front on empty StrBlob");
    3.     return data->front();
    4. }
    5.  
    6. string& StrBlob::back() const {
    7.     check(0, "back on empty StrBlob");
    8.     return data->back();
    9. }

    12.3：

    不需要，因为这两个函数都不会对参数进行修改。

    12.4：

    因为data_size类型是size_type，是一个无符号类型，即使是负数，也会自动转化为非负。

    12.5：

    explicit的作用就是抑制构造函数的隐式转换。

    优点：不会自动的进行类型转换，必须清楚的知道类类型。

    缺点：必须用构造函数显示创建一个对象，不够方便简单。

    12.1.2 直接管理内存（12.6 ~ 12.9）

    12.6：

    1. void Input(vector<int>* ivec){
    2.     if(!ivec) return;
    3.     string s;
    4.     while(cin >> s){
    5.         stringstream a(s);
    6.         int i;
    7.         a >> i;
    8.         ivec->push_back(i);
    9.     }
    10. }
    11.  
    12. void Output(vector<int>* ivec) {
    13.     if(!ivec) return;
    14.     for(const auto& i : *ivec){
    15.         cout << i << " ";
    16.     }
    17.     cout << endl;
    18. }
    19.  
    20. int main() {
    21.     auto ivec = IntVectorPointerFactory();
    22.     Input(ivec);
    23.     Output(ivec);
    24.     delete ivec;
    25.     ivec = nullptr;
    26. }
    27. // 1 1 1 sdf
    28. // ^Z
    29. // 1 1 1 0

    12.7：

    1. shared_ptrint>> IntVectorPointerFactory(){
    2.     return make_sharedint>>();
    3. }
    4.  
    5. void Input(const shared_ptrint>>& ivec){
    6.     if(!ivec) return;
    7.     string s;
    8.     while(cin >> s){
    9.         stringstream a(s);
    10.         int i;
    11.         a >> i;
    12.         ivec->push_back(i);
    13.     }
    14. }
    15.  
    16. void Output(const shared_ptrint>>& ivec) {
    17.     if(!ivec) return;
    18.     for(const auto& i : *ivec){
    19.         cout << i << " ";
    20.     }
    21.     cout << endl;
    22. }
    23.  
    24. int main() {
    25.     auto ivec = IntVectorPointerFactory();
    26.     Input(ivec);
    27.     Output(ivec);
    28. }
    29. // 1 1 1 sdf
    30. // ^Z
    31. // 1 1 1 0

    12.8：

    p的类型是int*，函数返回值却是bool型。(错误答案)

    p是一个内置类型的指针，返回p会使得p的类型转化为bool类型，其指向的动态内存空间将无法得到释放。

    12.9：

    r = q，r指向q指向的内存地址，r原指向的内存未发生任何改变；（补充：r原来指向的内存空间将得不到释放，造成内存泄漏）

    r2 = q2，q2智能指针的引用计数加一，r2智能指针的引用计数减一，原指针指向的内存释放，现r2指针指向q2。

    12.1.3 shared_ptr和new结合使用（12.10 ~ 12.13）

    12.10：

    正确的，shared_ptr p(new int(42))，引用计数+1，shared_ptr(p)引用计数+1，process调用后，引用计数减1，最后还剩1，可以正确使用。

    12.11：

    process调用结束后，指针析构，p被销毁，p指向的内存被释放了，再使用p就是未定义。

    12.12：

    (a) 合法，复制sp引用计数+1，调用完引用计数-1，不影响原sp的使用。

    (b) 不合法，不能传递内置指针给shared_ptr，无法隐式转换。

    (c) 不合法，与(b)同样的原因，不能传递内置指针给shared_ptr，无法隐式转换。

    (d) 合法，但process调用完后不能再使用p，因为p指向的内存被释放。

    12.13：

    抄的答案：删除p之后，会导致p指向的内存被释放，此时sp就会变成空悬指针，在sp指针被销毁时，该块内存会被二次delete，执行后产生错误：double free

    12.1.4 智能指针和异常（12.14 ~ 12.15）

    12.14：

    没有想到其他写法。

    12.15：

    1. void f(destination &d /* 其他参数 */) {
    2. 	connection c = connect(&d);
    3.     shared_ptr p(&c , [](connection *p){
    4.         disconnect(*p);
    5.     });
    6. }

    12.1.5 unique_ptr（12.16 ~ 12.18）

    12.16：

    1. unique_ptr<int> p1(new int(10));
    2. unique_ptr<int> p2(p1);
    3. // unique_ptr p2 = p1;

    error: use of deleted function 'std::unique_ptr<Tp, _Dp>::unique_ptr(const std::unique_ptr<Tp, _Dp>&) [with _Tp = int; _Dp = std::default_delete]'|

    以下网上答案，没理解

    error C2248: “std::unique_ptr<Ty>::unique_ptr”: 无法访问 private 成员(在“std::unique_ptr<Ty>”类中声明)

    12.17：

    （a）不合法，不能用对象初始化unique_ptr；

    （b）合法，pi野指针；

    （c）合法，pi2野指针；

    （d）合法，ix对象被清空；

    （e）合法；

    （f）不合法，一块内存对象只能被一个unique_ptr持有。

    和网络答案不一致，但也没有很理解，以上为个人理解，欢迎指正。

    12.18：

    shared_ptr指向的对象可以同时被多个shared_ptr持有，release会将指针置为空，导致其他持有这个指针的shared_ptr对象失效。

    12.1.6 weak_ptr（12.19 ~ 12.22）

    12.19：

    1. // 这里的代码主要有两个问题
    2. // 1.循环引用 可以在类中声明 在StrBlobPtr后再定义begin end
    3. // 2.需要额外给StrBlobPtr类添加pos函数来比较
    4. class StrBlobPtr;
    5. class StrBlob {
    6. public:
    7.     typedef std::vector::size_type size_type;
    8.     friend class StrBlobPtr;
    9.     StrBlob();
    10.     StrBlob(std::initializer_list il);
    11.     size_type size() const { return data->size(); }
    12.     bool empty() const { return data->empty(); }
    13.     void push_back(const std::string& t) { data->push_back(t); }
    14.     void pop_back();
    15.     std::string& front();
    16.     std::string& back();
    17.     StrBlobPtr begin();
    18.     StrBlobPtr end();
    19. private:
    20.     std::shared_ptr> data;
    21.     void check(size_type i, const std::string& msg) const;
    22. };
    23.  
    24. StrBlob::StrBlob() : data(make_shared>()) {
    25.  
    26. }
    27.  
    28. StrBlob::StrBlob(initializer_list il) : data(make_shared>(il)) {
    29.  
    30. }
    31.  
    32. string& StrBlob::front() {
    33.     check(0, "front on empty StrBlob");
    34.     return data->front();
    35. }
    36.  
    37. string& StrBlob::back() {
    38.     check(0, "back on empty StrBlob");
    39.     return data->back();
    40. }
    41.  
    42. void StrBlob::pop_back() {
    43.     check(0, "pop_back on empty StrBlob");
    44.     data->pop_back();
    45. }
    46.  
    47. void StrBlob::check(size_type i, const string& msg) const {
    48.     if(i >= data->size()) {
    49.         throw out_of_range(msg);
    50.     }
    51. }
    52.  
    53. class StrBlobPtr {
    54. public:
    55.     StrBlobPtr() : curr(0) { }
    56.     StrBlobPtr(StrBlob &a, size_t sz = 0) : wptr(a.data), curr(sz) { }
    57.     std::string& deref() const;
    58.     StrBlobPtr& incr();
    59.     size_t pos() const;
    60. private:
    61.     std::shared_ptr> check(std::size_t, const std::string&) const;
    62.     std::weak_ptr> wptr;
    63.     std::size_t curr;
    64. };
    65.  
    66. std::string& StrBlobPtr::deref() const {
    67.     auto p = check(curr, "dereference past end");
    68.     return (*p)[curr];
    69. }
    70.  
    71. StrBlobPtr& StrBlobPtr::incr() {
    72.     check(curr, "increment past end of StrBlobPtr");
    73.     ++curr;
    74.     return *this;
    75. }
    76.  
    77. std::shared_ptr> StrBlobPtr::check(std::size_t i, const std::string &msg) const {
    78.     auto ret = wptr.lock();
    79.     if(!ret)
    80.         throw std::runtime_error("unbound StrBlobPtr");
    81.     if(i >= ret->size())
    82.         throw std::out_of_range(msg);
    83.     return ret;
    84. }
    85.  
    86. size_t StrBlobPtr::pos() const {
    87.     return curr;
    88. }
    89.  
    90. StrBlobPtr StrBlob::begin() {
    91.     return StrBlobPtr(*this);
    92. }
    93.  
    94. StrBlobPtr StrBlob::end() {
    95.     auto ret = StrBlobPtr(*this, data->size());
    96.     return ret;
    97. }

    12.20：

    1. int main() {
    2.     std::string str{};
    3.     StrBlob str_blob{};
    4.     while(cin >> str) {
    5.         str_blob.push_back(str);
    6.     }
    7.     for (StrBlobPtr pbeg(str_blob.begin()), pend(str_blob.end()); pbeg.pos() != pend.pos(); pbeg.incr()) {
    8.         cout << pbeg.deref() << std::endl;
    9.     }
    10. }

    12.21：

    将合法性检查与元素获取的返回语句分离开来，代码更清晰易读。

    12.22：

    StrBlobPtr(const StrBlob &a, size_t sz = 0) : wptr(a.data), curr(sz) { }

    12.2 动态数组

    12.2.1 new和数组（12.23 ~ 12.25）

    12.23：

    1. // dynamically allocated array of char
    2. char *concatenate_string = new char[strlen("hello " "world") + 1]();
    3. strcat(concatenate_string, "hello ");
    4. strcat(concatenate_string, "world");
    5. std::cout << concatenate_string << std::endl;
    6. delete [] concatenate_string;
    7.  
    8. // std::string
    9. std::string str1{ "hello " }, str2{ "world" };
    10. std::cout << str1 + str2 << std::endl;
    11.  
    12. // hello world
    13. // hello world
    14. // copy from https://github.com/Mooophy/Cpp-Primer/blob/master/ch12/ex12_23.cpp

    12.24：

    1. string str;
    2. cin >> str;
    3. char *input = new char[str.size() + 1]();
    4. strcat(input, str.c_str());
    5. cout << input << endl;
    6. delete [] input;
    7. // input: helloworld
    8. // output: helloworld

    12.25：

    delete [] pa;

    12.2.2 allocator（12.26）

    12.26：

    1. allocator alloc;           // 可以分配string的allocator对象
    2. auto const p = alloc.allocate(n);  // 分配n个未初始化的string
    3. string s;
    4. auto q = p;
    5. while(cin >> s && q != p + n)
    6.     alloc.construct(q++, s);
    7.  
    8. // 输出 & 析构
    9. while(q != p) {
    10.     cout << *--q << endl;
    11.     alloc.destroy(q);
    12. }
    13.  
    14. // 释放内存
    15. alloc.deallocate(p, n);

    12.3 使用标准库：文本查询程序

    12.3.1 文本查询程序设计（12.27 ~ 12.29）

    12.27：

    1. class TextQuery{
    2. public:
    3.     TextQuery(ifstream &infile);
    4.     void query(string s);
    5.  
    6. private:
    7.     vector line_text_{};
    8.     mapsize_t>> word_lines_{};
    9. };
    10.  
    11. TextQuery::TextQuery(ifstream &infile){
    12.     string line_string;
    13.     size_t line = 1;
    14.     while(getline(infile, line_string)){
    15.         cout << line_string << endl;
    16.         line_text_.push_back(line_string);
    17.         istringstream stream(line_string);
    18.         string word;
    19.         while(stream >> word){
    20.             auto iter = word_lines_.find(word);
    21.             set<size_t> lines{};
    22.             if(iter != word_lines_.end()) {
    23.                 lines = iter->second;
    24.             }
    25.             lines.insert(line);
    26.             word_lines_[word] = lines;
    27.         }
    28.         line++;
    29.     }
    30. }
    31.  
    32. void TextQuery::query(string s) {
    33.     auto iter = word_lines_.find(s);
    34.     if(iter != word_lines_.end()){
    35.         auto lines = iter->second;
    36.         cout << s << " occurs " << lines.size() << " times" << endl;
    37.         for(const auto index : lines) {
    38.             if(index >= 1 && index <= line_text_.size()){
    39.                 cout << "(line "<< index << ") " << line_text_[index - 1] << endl;
    40.             }
    41.         }
    42.     }
    43.  
    44. }
    45.  
    46. void runQueries(ifstream &infile) {
    47.     // infile 是一个ifstream，指向我们要处理的文件
    48.     TextQuery tq(infile);  // 保存文件并建立查询map
    49.     // 与用户交互：提示用户输入要查询的单词，完成查询并打印结果
    50.     while(true) {
    51.         cout << "enter word to look for, or q to quit: ";
    52.         string s;
    53.         // 若遇到文件尾或用户输入了'q'时循环终止
    54.         if(!(cin >> s) || s == "q") break;
    55.         // 指向查询并打印结果
    56.         //print(cout, tq.query(s)) << endl;
    57.          tq.query(s);
    58.     }
    59. }
    60.  
    61. int main() {
    62.     ifstream fstrm1("1.txt");
    63.     runQueries(fstrm1);
    64. }
    65.  
    66. // 自己写的 有点简单 只用了一个类 也没有用到智能指针
    67. // 输入是文件1.txt 会打印出输入的内容
    68. /*
    69. brb be right back
    70. k okay?
    71. y why
    72. r are
    73. u you
    74. pic picture
    75. thk thanks~
    76. 18r later
    77. k okay!
    78. enter word to look for, or q to quit: k
    79. k occurs 2 times
    80. (line 2) k okay?
    81. (line 9) k okay!
    82. enter word to look for, or q to quit: r
    83. r occurs 1 times
    84. (line 4) r are
    85. enter word to look for, or q to quit: q
    86. */
    87. // https://github.com/Mooophy/Cpp-Primer/tree/master/ch12 移除了输入中的标点符号

    12.28：

    1. int main() {
    2.     ifstream fstrm1("1.txt");
    3.  
    4.     vector line_text{};
    5.     mapsize_t>> word_lines{};
    6.  
    7.     string line_string;
    8.     size_t line = 1;
    9.     while(getline(fstrm1, line_string)){
    10.         cout << line_string << endl;
    11.         line_text.push_back(line_string);
    12.         istringstream stream(line_string);
    13.         string word;
    14.         while(stream >> word){
    15.             auto iter = word_lines.find(word);
    16.             set<size_t> lines{};
    17.             if(iter != word_lines.end()) {
    18.                 lines = iter->second;
    19.             }
    20.             lines.insert(line);
    21.             word_lines[word] = lines;
    22.         }
    23.         line++;
    24.     }
    25.  
    26.     while(true) {
    27.         cout << "enter word to look for, or q to quit: ";
    28.         string s;
    29.         // 若遇到文件尾或用户输入了'q'时循环终止
    30.         if(!(cin >> s) || s == "q") break;
    31.         // 指向查询并打印结果
    32.         //print(cout, tq.query(s)) << endl;
    33.         auto iter = word_lines.find(s);
    34.         if(iter != word_lines.end()){
    35.             auto lines = iter->second;
    36.             cout << s << " occurs " << lines.size() << " times" << endl;
    37.             for(const auto index : lines) {
    38.                 if(index >= 1 && index <= line_text.size()){
    39.                     cout << "(line "<< index << ") " << line_text[index - 1] << endl;
    40.                 }
    41.             }
    42.         }
    43.     }
    44. }
    45.  
    46. // 输出与上面一致

    12.29：

    1. void runQueries(ifstream &infile) {
    2.     // infile 是一个ifstream，指向我们要处理的文件
    3.     TextQuery tq(infile);  // 保存文件并建立查询map
    4.     // 与用户交互：提示用户输入要查询的单词，完成查询并打印结果
    5.  
    6.     do{
    7.         cout << "enter word to look for, or q to quit: ";
    8.         string s;
    9.         // 若遇到文件尾或用户输入了'q'时循环终止
    10.         if(!(cin >> s) || s == "q") break;
    11.         // 指向查询并打印结果
    12.         //print(cout, tq.query(s)) << endl;
    13.         tq.query(s);
    14.     }
    15.     while(true);
    16. }
    17.  
    18. // 倾向于直接用while，清晰
    19. // https://www.cnblogs.com/songshuguiyu/p/9598196.html 这里写do while更简洁…

    12.3.2 文本查询程序类的定义（12.30 ~ 12.33）

    12.30：

    1. class QueryResult;  // 为了定义函数query的返回类型
    2. class TextQuery {
    3. public:
    4.     using line_no = std::vector::size_type;
    5.     TextQuery(std::ifstream&);
    6.     QueryResult query(const std::string&) const;
    7. private:
    8.     std::shared_ptr> file;  // 输入文件
    9.     // 每个单词到它所在的行号的集合的映射
    10.     std::map>> wm;
    11. };
    12.  
    13. TextQuery::TextQuery(ifstream &is) : file(new vector) {
    14. 	string text;
    15.     while(getline(is, text)) {     // 对文件中每一行
    16.         file->push_back(text);     // 保存此行文本
    17.         int n = file->size() - 1;  // 当前行号
    18.         istringstream line(text);  // 将行文本分解为单词
    19.         string word;
    20.         while(line >> word) {  // 对行中每个单词
    21.     		// 如果单词不在wm中，以之为下标在wm中添加一项
    22.             auto &lines = wm[word];  // lines是shared_ptr（如果lines为空没有使用引用是会失败的）
    23.             if(!lines)  // 在第一次遇到此单词时，此指针为空
    24.                 lines.reset(new set);  // 分配一个新的set
    25.             lines->insert(n);  // 将此行号插入set中
    26.         }
    27.     }
    28. }
    29.  
    30. class QueryResult {
    31.     friend std::ostream& print(std::ostream&, const QueryResult&);  // 友元函数不需要放在public或private里吗？
    32. public:
    33.     QueryResult(std::string s, std::shared_ptr> p, std::shared_ptr> f) : sought(s), lines(p), file(f) { }
    34. private:
    35.     std::string sought;  // 查询单词
    36.     std::shared_ptr> lines;  // 出现的行号
    37.     std::shared_ptr> file;  // 输入文字
    38. };
    39.  
    40. QueryResult TextQuery::query(const string & sought) const {
    41.     // 如果未找到sought，将返回指向此set的指针
    42.     static shared_ptr> nodata(new set);
    43.     // 使用find而不是下标运算符来查找单词，避免将单词添加到wm中！
    44.     auto loc = wm.find(sought);
    45.     if(loc == wm.end())
    46.         return QueryResult(sought, nodata, file);  // 未找到
    47.     else
    48.         return QueryResult(sought, loc->second, file);
    49. }
    50.  
    51. void runQueries(ifstream &infile) {
    52.     // infile 是一个ifstream，指向我们要处理的文件
    53.     TextQuery tq(infile);  // 保存文件并建立查询map
    54.     // 与用户交互：提示用户输入要查询的单词，完成查询并打印结果
    55.     while(true) {
    56.         cout << "enter word to look for, or q to quit: ";
    57.         string s;
    58.         // 若遇到文件尾或用户输入了'q'时循环终止
    59.         if(!(cin >> s) || s == "q") break;
    60.         // 指向查询并打印结果
    61.         print(cout, tq.query(s)) << endl;
    62.     }
    63. }
    64.  
    65. string make_plural(size_t ctr, const string &word, const string &ending) {
    66.     return ctr > 1 ? word + ending : word;
    67. }
    68.  
    69. ostream &print(ostream &os, const QueryResult &qr) {
    70.     // 如果找到了单词，打印出现次数和所有出现的位置
    71.     os << qr.sought << " occurs " << qr.lines->size() << " " << make_plural(qr.lines->size(), "times", "s") << endl;
    72.     // 打印单词出现的每一行
    73.     for(auto num : *qr.lines)  // 对set中每个单词
    74.         // 避免行号从0开始给用户带来的困惑
    75.         os << "\t(line " << num + 1 << ") " << *(qr.file->begin() + num) << endl;
    76.     return os;
    77. }
    78.  
    79. int main() {
    80.     ifstream fstrm1("1.txt");
    81.     runQueries(fstrm1);
    82. }
    83. // 12.27写过了，这里将书中的代码copy运行

    12.31：

    一行中有两个重复的单词，输出时，如果vector不过滤，会将这一行输出两遍，使用set不用过滤。

    12.32：

    1. class StrBlobPtr;
    2.  
    3. class StrBlob {
    4. public:
    5.     typedef std::vector::size_type size_type;
    6.     friend class StrBlobPtr;
    7.     StrBlob();
    8.     StrBlob(std::initializer_list il);
    9.     size_type size() const { return data->size(); }
    10.     bool empty() const { return data->empty(); }
    11.     void push_back(const std::string& t) { data->push_back(t); }
    12.     void pop_back();
    13.     std::string& front();
    14.     std::string& back();
    15.     StrBlobPtr begin();
    16.     StrBlobPtr end();
    17. private:
    18.     std::shared_ptr> data;
    19.     void check(size_type i, const std::string& msg) const;
    20. };
    21.  
    22. StrBlob::StrBlob() : data(make_shared>()) {
    23.  
    24. }
    25.  
    26. StrBlob::StrBlob(initializer_list il) : data(make_shared>(il)) {
    27.  
    28. }
    29.  
    30. string& StrBlob::front() {
    31.     check(0, "front on empty StrBlob");
    32.     return data->front();
    33. }
    34.  
    35. string& StrBlob::back() {
    36.     check(0, "back on empty StrBlob");
    37.     return data->back();
    38. }
    39.  
    40. void StrBlob::pop_back() {
    41.     check(0, "pop_back on empty StrBlob");
    42.     data->pop_back();
    43. }
    44.  
    45. void StrBlob::check(size_type i, const string& msg) const {
    46.     if(i >= data->size()) {
    47.         throw out_of_range(msg);
    48.     }
    49. }
    50.  
    51. class StrBlobPtr {
    52. public:
    53.     StrBlobPtr() : curr(0) { }
    54.     StrBlobPtr(const StrBlob &a, size_t sz = 0) : wptr(a.data), curr(sz) { }
    55.     std::string& deref() const;
    56.     StrBlobPtr& incr();
    57.     size_t pos() const;
    58. private:
    59.     std::shared_ptr> check(std::size_t, const std::string&) const;
    60.     std::weak_ptr> wptr;
    61.     std::size_t curr;
    62. };
    63.  
    64. std::string& StrBlobPtr::deref() const {
    65.     auto p = check(curr, "dereference past end");
    66.     return (*p)[curr];
    67. }
    68.  
    69. StrBlobPtr& StrBlobPtr::incr() {
    70.     check(curr, "increment past end of StrBlobPtr");
    71.     ++curr;
    72.     return *this;
    73. }
    74.  
    75. std::shared_ptr> StrBlobPtr::check(std::size_t i, const std::string &msg) const {
    76.     auto ret = wptr.lock();
    77.     if(!ret)
    78.         throw std::runtime_error("unbound StrBlobPtr");
    79.     if(i >= ret->size())
    80.         throw std::out_of_range(msg);
    81.     return ret;
    82. }
    83.  
    84. size_t StrBlobPtr::pos() const {
    85.     return curr;
    86. }
    87.  
    88. StrBlobPtr StrBlob::begin() {
    89.     return StrBlobPtr(*this);
    90. }
    91.  
    92. StrBlobPtr StrBlob::end() {
    93.     auto ret = StrBlobPtr(*this, data->size());
    94.     return ret;
    95. }
    96.  
    97. class QueryResult;  // 为了定义函数query的返回类型
    98. class TextQuery {
    99. public:
    100.     using line_no = std::vector::size_type;
    101.     TextQuery(std::ifstream&);
    102.     QueryResult query(const std::string&) const;
    103. private:
    104.     std::shared_ptr> file;  // 输入文件
    105.     std::shared_ptr file2;
    106.     // 每个单词到它所在的行号的集合的映射
    107.     std::map>> wm;
    108. };
    109.  
    110. TextQuery::TextQuery(ifstream &is) : file2(make_shared()) {
    111. 	string text;
    112.     while(getline(is, text)) {     // 对文件中每一行
    113.         file2->push_back(text);     // 保存此行文本
    114.         int n = file2->size() - 1;  // 当前行号
    115.         istringstream line(text);  // 将行文本分解为单词
    116.         string word;
    117.         while(line >> word) {  // 对行中每个单词
    118.     		// 如果单词不在wm中，以之为下标在wm中添加一项
    119.             auto &lines = wm[word];  // lines是shared_ptr（如果lines为空没有使用引用是会失败的）
    120.             if(!lines)  // 在第一次遇到此单词时，此指针为空
    121.                 lines.reset(new set);  // 分配一个新的set
    122.             lines->insert(n);  // 将此行号插入set中
    123.         }
    124.     }
    125. }
    126.  
    127. class QueryResult {
    128.     friend std::ostream& print(std::ostream&, const QueryResult&);  // 友元函数不需要放在public或private里吗？
    129. public:
    130.     QueryResult(std::string s, std::shared_ptr> p, std::shared_ptr f) : sought(s), lines(p), file2(f) { }
    131. private:
    132.     std::string sought;  // 查询单词
    133.     std::shared_ptr> lines;  // 出现的行号
    134.     std::shared_ptr> file;  // 输入文字
    135.     std::shared_ptr file2;  // 输入文字
    136. };
    137.  
    138. QueryResult TextQuery::query(const string & sought) const {
    139.     // 如果未找到sought，将返回指向此set的指针
    140.     static shared_ptr> nodata(new set);
    141.     // 使用find而不是下标运算符来查找单词，避免将单词添加到wm中！
    142.     auto loc = wm.find(sought);
    143.     if(loc == wm.end())
    144.         return QueryResult(sought, nodata, file2);  // 未找到
    145.     else
    146.         return QueryResult(sought, loc->second, file2);
    147. }
    148.  
    149. void runQueries(ifstream &infile) {
    150.     // infile 是一个ifstream，指向我们要处理的文件
    151.     TextQuery tq(infile);  // 保存文件并建立查询map
    152.     // 与用户交互：提示用户输入要查询的单词，完成查询并打印结果
    153.     while(true) {
    154.         cout << "enter word to look for, or q to quit: ";
    155.         string s;
    156.         // 若遇到文件尾或用户输入了'q'时循环终止
    157.         if(!(cin >> s) || s == "q") break;
    158.         // 指向查询并打印结果
    159.         print(cout, tq.query(s)) << endl;
    160.     }
    161. }
    162.  
    163. string make_plural(size_t ctr, const string &word, const string &ending) {
    164.     return ctr > 1 ? word + ending : word;
    165. }
    166.  
    167. ostream &print(ostream &os, const QueryResult &qr) {
    168.     // 如果找到了单词，打印出现次数和所有出现的位置
    169.     os << qr.sought << " occurs " << qr.lines->size() << " " << make_plural(qr.lines->size(), "times", "s") << endl;
    170.     // 打印单词出现的每一行
    171.     for(auto num : *qr.lines) { // 对set中每个单词
    172.         // 避免行号从0开始给用户带来的困惑
    173.         StrBlobPtr p(*qr.file2, num);
    174.         os << "\t(line " << num + 1 << ") " << p.deref() << endl;
    175.     }
    176.     return os;
    177. }
    178.  
    179. int main() {
    180.     ifstream fstrm1("1.txt");
    181.     runQueries(fstrm1);
    182. }
    183. // 将之前的StrBlob和StrBlobPtr也放过来了
    184. // 里面有一些上题无用的变量file没有删哇~

    12.33：

    1. class QueryResult {
    2.     using ResultIter = std::set::iterator;
    3.     friend std::ostream& print(std::ostream&, const QueryResult&);  // 友元函数不需要放在public或private里吗？
    4. public:
    5.     QueryResult(std::string s, std::shared_ptr> p, std::shared_ptr f) : sought(s), lines(p), file2(f) { }
    6.     ResultIter begin() const { return nos->begin(); }
    7.     ResultIter end() const { return nos->end(); }
    8.     shared_ptr get_file() const { return file2; }
    9. private:
    10.     std::string sought;  // 查询单词
    11.     std::shared_ptr> lines;  // 出现的行号
    12.     std::shared_ptr> file;  // 输入文字
    13.     std::shared_ptr file2;  // 输入文字
    14.     shared_ptr> nos;
    15. };
    16. // copy了一下这里的https://github.com/Mooophy/Cpp-Primer/blob/master/ch12/ex12_33.h

  • 相关阅读:
    Prometheus服务发现之kubernetes_sd_config
    CleanMyMac XMac苹果电脑专属系统优化工具
    自制Linux功能板
    用滑动条做调色板---cv2.getTrackbarPos()，cv2.creatTrackbar()
    【数据结构】树和二叉树的概念及结构（一）
    get和post
    quill富文本工具栏添加行高配置
    Spring Security加密和匹配
    C++进阶篇4---番外-AVL树
    27.在springboot中使用thymeleaf的属性inline(text, javascript 和 none)
  • 原文地址：https://blog.csdn.net/zjzytnn/article/details/125471550