Primer C++ 学习笔记(第十章)

最新推荐文章于 2023-02-28 22:52:53 发布
最新推荐文章于 2023-02-28 22:52:53 发布
阅读量209 收藏
点赞数
分类专栏： PrimerC++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42685012/article/details/102837462
版权

本书为Primer C++ 中文第五版

练习题笔记

在这里插入图片描述

(10.1)
void test1() {
    vector<int> ive = {0, 1, 2, 3, 4, 4, 4, 5};
    int val;
    while(cin >> val && val != 99) {
        cout << count(ive.begin(), ive.end(), val) << endl;
    }
}
(10.2)
void test2() {
    list<string> ive = {"a", "aa", "aaa", "a", "aa", "a", "b", "c"};
    string val;
    while(cin >> val && val != "q") {
        cout << count(ive.begin(), ive.end(), val) << endl;
    }
}

在这里插入图片描述

(10.3)
void test3() {
    vector<double> ive = {0, 1, 2, 3, 4, 4, 4, 5.8};
    cout << accumulate(ive.begin(), ive.end(), 0) << endl;
}
(10.4)
用0的话，则表明结果将会删除小数位。
所以最好是要设置小数位
(10.5)
equal是利用是使用==比较两个元素。
string重载了==，可以比较两个字符串是否等长且其中对应元素相等。
而C风格字符串
1如果是char*类型，没有影响。
2如果是char []类型，用==比较两个对象，会检查两个指针值是否相等，也就是地址是否相等。

在这里插入图片描述

(10.6)
void test6() {
    vector<int> ive(10);
    fill_n(ive.begin(), ive.size(), 0);
    for(auto i : ive) {
        cout << i << " ";
    }
    cout << endl;
}
(10.7)
a:
 //使用copy等算法的时候，确保目的容器至少包含于输入序列一样多的元素。
void test7() {
    list<int> lst; int i;
    while(cin >> i && i != 0)
        lst.push_back(i);
    vector<int> vec(lst.size());
    copy(lst.cbegin(), lst.cend(), vec.begin());
    for(auto i : vec) {
        cout << i << " ";
    }
    cout << endl;
}
或者
void test7() {
    list<int> lst; int i;
    while(cin >> i && i != 0)
        lst.push_back(i);
    vector<int> vec;
    copy(lst.cbegin(), lst.cend(), back_inserter(vec));
    for(auto i : vec) {
        cout << i << " ";
    }
    cout << endl;
}

b:
void test7_2() {
    vector<int> vec;
    //reserve预留空间，没有创建元素对象
    //resize改变容器大小，并且创建对象
    vec.resize(10);
    fill_n(vec.begin(), 10, 0);
    for(auto i : vec) {
        cout << i << " ";
    }
    cout << endl;
}
或者使用back_inserter(vec)；

(10.8)
标准库算法不直接操作容器，而是通过操作迭代器间接访问容器。是否能插入删除元素，取决于传递给这些算法的迭代器是否具有这样的能力。

在这里插入图片描述

(10.9)
void test9() {
    vector<string> sve = {"the", "quick", "red", "fox", "jumps", "over", "the", "slow", "red", "turtle"};
    sort(sve.begin(), sve.end());
    auto end_unique = unique(sve.begin(), sve.end());
    sve.erase(end_unique, sve.end());
    for(auto i : sve) {
        cout << i << " ";
    }
    cout << endl;
}
(10.10)
做到算法和数据结构的分离。
算法不操作具体的容器，只操作迭代器，然后由迭代器实现对容器的访问。
这样做的目的就是实现算法的通用性。

在这里插入图片描述

(10.11)
bool isShorter(const string &s1, const string &s2) {
    return s1.size() < s2.size();
}

void test11() {
    vector<string> sve = {"the", "quick", "red", "fox", "jumps", "over", "the", "slow", "red", "turtle"};
    sort(sve.begin(), sve.end());
    auto end_unique = unique(sve.begin(), sve.end());
    sve.erase(end_unique, sve.end());
    for(auto i : sve) {
        cout << i << " ";
    }
    cout << endl;
    sort(sve.begin(), sve.end(), isShorter);
    for(auto i : sve) {
        cout << i << " ";
    }
    cout << endl;
}

(10.12)
struct Sales_data {
    string bookNo;
    Sales_data(string bn) {
        bookNo = bn;
    };
    string isbn() {
        return bookNo;
    };
};

bool compareIsbn(Sales_data &sd1, Sales_data &sd2) {
    return sd1.isbn().size() < sd2.isbn().size();
}

void test12() {
    Sales_data book1("zl");
    Sales_data book2("zzzl");
    Sales_data book3("zzl");
    Sales_data book4("lz");
    vector<Sales_data> vsd = {book1, book2, book3, book4};
    sort(vsd.begin(), vsd.end(), compareIsbn);
    for(auto i : vsd) {
        cout << i.bookNo << " ";
    }
    cout << endl;
}

(10.13)
bool sizeMore5(const string &s) {
    return s.size() >= 5;
}

void test13() {
    vector<string> sve = {"the", "quick", "red", "fox", "jumps", "over", "the", "slow", "red", "turtle"};
    auto it_end = partition(sve.begin(), sve.end(), sizeMore5);
    for(auto cb = sve.cbegin(); cb < it_end; cb++) {
        cout << *cb << " ";
    }
    cout << endl;
}

在这里插入图片描述

(10.14)
void test14() {
    auto sum = [](int a, int b){return a+b;};
    cout << sum(3, 4) << endl;
}
(10.15)
void test15() {
    int m =10;
    auto sum = [m](int a){return a+m;};
    cout << sum(5) << endl;
}
(10.16)
void biggies(vector<string> &words, vector<string>::size_type sz) {
    sort(words.begin(), words.end());
    auto end_unique = unique(words.begin(), words.end());
    words.erase(end_unique, words.end());
    stable_sort(words.begin(), words.end(),
                [](const string &s1, const string &s2){return s1.size() < s2.size();});
    auto wc = find_if(words.begin(), words.end(),
                [sz](string &s){return s.size() >= sz;});
    auto count = words.end() - wc;
    cout << count << " "<< (count > 1 ? "words" : "word") << " of length "
         << sz << " or longger" << endl;
    for_each(wc, words.end(), [](string &s){ cout << s << " ";});
    cout << endl;

}

void test16() {
    vector<string> sve = {"the", "quick", "red", "fox", "jumps", "over", "the", "slow", "red", "turtle"};
    biggies(sve, 5);
}
(10.17)
void test17() {
    Sales_data book1("zl");
    Sales_data book2("zzzl");
    Sales_data book3("zzl");
    Sales_data book4("lz");
    vector<Sales_data> vsd = {book1, book2, book3, book4};
    sort(vsd.begin(), vsd.end(),
        [](Sales_data &sd1, Sales_data &sd2){return sd1.isbn().size() < sd2.isbn().size();});
    for(auto i : vsd) {
        cout << i.bookNo << " ";
    }
    cout << endl;
}
(10.18)
void test18(){
    vector<string> words = {"the", "quick", "red", "fox", "jumps", "over", "the", "slow", "red", "turtle"};
    int sz = 5;
    sort(words.begin(), words.end());
    auto end_unique = unique(words.begin(), words.end());
    words.erase(end_unique, words.end());
    stable_sort(words.begin(), words.end(),
                [](const string &s1, const string &s2){return s1.size() < s2.size();});
    auto wc = partition(words.begin(), words.end(),
                [sz](string &s){return s.size() < sz;});
    auto count = words.end() - wc;
    cout << count << " "<< (count > 1 ? "words" : "word") << " of length "
         << sz << " or longger" << endl;
    for_each(wc, words.end(), [](string &s){ cout << s << " ";});
    cout << endl;
}

(10.19)
void test19(){
    vector<string> words = {"the", "quick", "red", "fox", "jumps", "over", "the", "slow", "red", "turtle"};
    int sz = 5;
    sort(words.begin(), words.end());
    auto end_unique = unique(words.begin(), words.end());
    words.erase(end_unique, words.end());
    stable_sort(words.begin(), words.end(),
                [](const string &s1, const string &s2){return s1.size() < s2.size();});
    auto wc = stable_partition(words.begin(), words.end(),
                [sz](string &s){return s.size() < sz;});
    auto count = words.end() - wc;
    cout << count << " "<< (count > 1 ? "words" : "word") << " of length "
         << sz << " or longger" << endl;
    for_each(wc, words.end(), [](string &s){ cout << s << " ";});
    cout << endl;
}

在这里插入图片描述

(10.20)
void test20() {
    vector<string> words = {"the", "quick", "red", "fox", "jumps", "over", "the", "slow", "red", "turtle"};
    auto count = count_if(words.begin(), words.end(),
                [](const string &s){return s.size() > 6;});
    cout << count << endl;
}

(10.21)
void test21() {
    int m = 5;
    auto b = [&m]()->bool{return --m;};
    while(b());
    cout << m << endl;
}

在这里插入图片描述

(10.22)
bool shorterThan(const string &s, int l) {
    return s.size() <= l;
}

void test22() {
    vector<string> words = {"the", "quick", "red", "fox", "jumps", "over", "the", "slow", "red", "turtle"};
    auto count = count_if(words.begin(), words.end(),
                bind(shorterThan, placeholders::_1, 6));
    cout << count << endl;
}

(10.23)
bind接受的参数与它绑定的函数相关，函数接受n个参数，则bind接受n+1个参数
(10.24)
bool shorter(const string &s, int l) {
    return s.size() < l;
}

void test24() {
    vector<int> ive = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    string s;
    while(cin >> s && s != "q") {
        auto iter = find_if(ive.begin(), ive.end(), bind(shorter, s, placeholders::_1));
        if(iter != ive.end()) cout << *iter << endl;
    }
}

(10.25)
bool check_size(const string &s, int l) {
    return s.size() >= l;
}

void test25() {
    vector<string> words = {"the", "quick", "red", "fox", "jumps", "over", "the", "slow", "red", "turtle"};
    sort(words.begin(), words.end());
    auto end_unique = unique(words.begin(), words.end());
    words.erase(end_unique, words.end());
    stable_sort(words.begin(), words.end(),
                [](const string &s1, const string &s2){return s1.size() < s2.size();});
    auto wc = find_if(words.begin(), words.end(), bind(check_size, placeholders::_1, 5));
    auto count = words.end() - wc;
    cout << count << " "<< (count > 1 ? "words" : "word") << " of length 5 or longger" << endl;
    for_each(wc, words.end(), [](string &s){ cout << s << " ";});
    cout << endl;

}

在这里插入图片描述

(10.26)
back_inserter 创建一个使用push_back的迭代器
front_inserter 穿件一个使用push_front的迭代器
inserter 创建一个使用insert的迭代器，此函数接受第二个参数，这个参数必须是一个指向给定容器的迭代器。元素将被插入到给定迭代器所表示的元素之前。
在使用back_inserter和front_inserter的时候要确保容器支持push_back和push_front。
(10.27)
void test27() {
    vector<int> ive = {1, 2, 2, 3, 3, 3, 4, 5};
    list<int> lst;
    unique_copy(ive.begin(), ive.end(), inserter(lst, lst.begin()));
    for(auto i : lst) cout << i << " ";
    cout << endl;
}

(10.28)
void test28() {
    vector<int> ori = {1, 2, 3, 4, 5, 6, 7, 8, 9};
    vector<int> ive, bve;
    list<int> fve;
    copy(ori.rbegin(), ori.rend(), front_inserter(fve));
    copy(ori.begin(), ori.end(), back_inserter(bve));
    copy(ori.begin(), ori.end(), inserter(ive, ive.begin()));
    for(auto i : fve) cout << i << " ";
    cout << endl;
    for(auto i : bve) cout << i << " ";
    cout << endl;
    for(auto i : ive) cout << i << " ";
    cout << endl;

}

在这里插入图片描述

(10.29)
void test29() {
    ifstream in("test.txt");
    istream_iterator<string> str_it(in), end;
    ostream_iterator<string> out_iter(cout, " ");
    copy(str_it, end, out_iter);
    cout << endl;
}

(10.30)
void test30() {
    istream_iterator<int> in(cin), eof;
    ostream_iterator<int> out(cout, " ");
    vector<int> ive(in, eof);
    sort(ive.begin(), ive.end());
    copy(ive.begin(), ive.end(), out);
}

(10.31)
void test31() {
    istream_iterator<int> in(cin), eof;
    ostream_iterator<int> out(cout, " ");
    vector<int> ive(in, eof);
    sort(ive.begin(), ive.end());
    unique_copy(ive.begin(), ive.end(), out);
}

(10.32)
struct Sale_data {
    string bookNo;
    double price;
    int num;
};

istream &operator>>(istream &is, Sale_data &item) {
    is >> item.bookNo >> item.price >> item.num;
    return is;
}

ostream &operator<<(ostream &os,const Sale_data &item) {
    os << item.bookNo << " " << item.price << " " << item.num;
    return os;
}

bool compareIsbn(const Sale_data &sd1, const Sale_data &sd2) {
    return sd1.bookNo.size() < sd2.bookNo.size();
}

void test32() {
    istream_iterator<Sale_data> in(cin), eof;
    ostream_iterator<Sale_data> out(cout, "\n");
    vector<Sale_data> sve(in, eof);
    copy(sve.begin(), sve.end(), out);
    sort(sve.begin(), sve.end(), compareIsbn);
    copy(sve.begin(), sve.end(), out);
}

(10.33)
void oddEven(const string &in, const string &odd, const string &even) {
    ifstream fin(in);
    ofstream foutodd(odd);
    ofstream fouteven(even);
    istream_iterator<int> i(fin), eof;
    ostream_iterator<int> oodd(foutodd, "\n");
    ostream_iterator<int> oeven(fouteven, "\n");
    while(i != eof) {
        if(*i%2) oodd = *i;
        else oeven = *i;
        i++;
    }
}

void test33() {
    oddEven("num.txt", "odd.txt", "even.txt");
}

在这里插入图片描述在这里插入图片描述

(10.34)
void test34() {
    ifstream fin("num.txt");
    istream_iterator<int> in(fin), eof;
    vector<int> ive(in, eof);
    for(auto rbe = ive.crbegin(); rbe < ive.crend(); ++rbe) {
        cout << *rbe << " ";
    }
    cout << endl;
}

(10.35)
void test35() {
    ifstream fin("num.txt");
    istream_iterator<int> in(fin), eof;
    vector<int> ive(in, eof);
    for(auto end = ive.cend() - 1; end >= ive.cbegin(); --end) {
        cout << *end << " ";
    }
    cout << endl;
}

(10.36)
void test36() {
    list<int> lst = {0, 1, 2, 3, 0, 1, 2, 0, 2, 3, 0, 4};
    auto last = find(lst.crbegin(), lst.crend(), 0);
    cout << *last << *last.base() << endl;
}

(10.37)
void test37() {
    vector<int> ive = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    list<int> lst(ive.crbegin()+2, ive.crend()-3);
    for(auto i : lst) cout << i << " ";
    cout << endl;
}

在这里插入图片描述

(10.38)
输入迭代器，find和accumulate要求输入迭代器，istream_iterator是一种输入迭代器
输出迭代器，copy函数的第三个参数就是输出迭代器，ostream_iterator类型也是输出迭代器
前向迭代器，replace要求前向迭代器，forward_list上的迭代器是前向迭代器
双向迭代器，reverse要求双向迭代器，处理forward_list，其他标准库都提供符合双向迭代器要求的迭代器
随机访问迭代器，sort要求随机访问迭代器，array、deque、string和vector的迭代器都是随机访问迭代器，用于访问内置数组元素的指针也是。
(10.39)
list上的迭代器属于双向迭代器
vector上的迭代器属于随机访问迭代器
(10.40)
copy要求输出迭代器
reverse要求双向迭代器
unique要求前向迭代器

在这里插入图片描述

(10.41)
replace 把迭代器范围内的old_val替换成new_val
replace_if 把迭代器范围内使得pred为true的值替换成new_val
replace_copy 和 replace() 做的事是一样的，但它的结果会被保存到另一个序列中，而不会改变原始序列
replace_copy_if()，它和 replace_if() 算法是相同的，但它的结果会被保存到另一个序列中

在这里插入图片描述

void test42() {
    list<string> lst = {"the", "quick", "red", "fox", "jumps", "over", "the", "slow", "red", "turtle"};
    lst.sort();
    lst.unique();
    for(auto s : lst) cout << s << " "; cout << endl;
}
胖狗子修行之路
关注
专栏目录
C++primer学习笔记及作业答案之第十章
blue_coffeei的博客
05-09 591
笔记： 1.概述 迭代器令算法不依赖于容器，但算法依赖于元素类型的操作。 标准库通过算法和数据结构的分离来实现泛型。 算法永远不会改变底层容器的大小。 2.初识泛型算法 C风格字符串本质是char *类型，用==比较两个char *对象，只是检查两个指针值是否相等，即地址是否相等，而不会比较其中字符是否相同 标准库算法从来不直接操作容器，它们只操作迭代器，从而间接访问容器。能不能插入...
《C Primer Plus》学习笔记—第10章
chaofeng426的博客
01-12 785
数组，初始化，const运算符； 数组边界，数组索引，指针； 二维数组，多维数组； 函数、数组和指针，指针形参； 指针表示法，数组表示法； 指针操作，const的使用； 变长数组VLA； 复合字面量
c++primer第十章笔记
风清扬zld的博客
07-08 273
10.1  pair类型 1:关联容器和顺序容器的本质差别在于：关联容器通过键（key）存储和读取元素，而顺序容器则通过元素在容器中的位置顺序存储和访问元素。 2:map 的元素以键－值（key-value）对的形式组织：键用作元素在 map 中的索引，而值则表示所存储和读取的数据。 3:pair类型在 utility 头文件中定义 4：pairs类型提供的操作： pair  p1;  
C++Primer学习笔记(10)
qq_42987967的博客
02-25 690
这篇文章的内容是关联容器。 顺序容器靠位置索引，关联容器靠关键字索引。
C++ Primer （第十章：泛型算法）
patrick_star 的博客
03-10 255
一丶因为这些算法只作用于迭代器，而不直接对容器进行操作.本阶段所学到的一些泛型算法：find()搜索，accmulate()求和，equal()相等判断，fill()、fill_n()赋值，back_insert()插入操作，copy()拷贝，sort()排序，unique()重排并消重复二丶reverse是改变容器容量的，并没有改变其大小，用resize()算法只是产生了一个插入迭代器，然后使用...
C++Primer——第10章(泛型算法)
杉杉coming！
07-31 270
10.1 泛型算法概述 本章提到的泛型算法： find InputItfind(InputIt first, InputIt last,constT&value)； first，last ，value分别为 两个标记范围的迭代器、目标查找值。 返回值：如果找到给定目标值，返回对应的迭代器，否则返回第二个参数，即标记结尾的迭代器。 accumulate Taccumulate(InputIt first, InputIt last, T init)； ...
C Primer Plus 前十章学习笔记
weixin_61049006的博客
10-18 186
第一章 初始C语言 c语言源代码--编译机器语言代码--链接 目标代码、库代码和启动代码（.c--.obj--.exe）--运行。 启动代码是充当程序和操作系统之间的接口。 编程的七个步骤：1.定义程序的目标 2.设计程序 3.编写代码 4.编译 5.运行程序6.测试和调试程序7.维护和修改程序（前两步可以用注释写在 编辑器 里面 即 目标--设计--写） 如果执行程序的窗口立即消失，可以用getchar（）让程序暂停，直到从控制台读取一个字符。...
C++Primer Plus（第六版）第十章学习笔记：
baidu_29452653的博客
03-15 214
面向对象编程(OOP) 特性 抽象； 封装和数据隐藏 多态 继承 代码可重用性 实现以上特性，从而引进了类 10.2 抽象和类 简单的说，就像看三体的时候那个概念，四维看三维的时候，是可以看到三维物体的所有层面，就像把所有三维物体的所有性质都铺开在眼前了，抽象就是这种感觉，把一个物体的关键的性质都抽象出来铺开，一目了然 10.2.1 类型是什么 对类型的声明就是确定该变量所会执行到的操作，所以...
C++Primer学习（第十章）
jiangnan3797的博客
05-14 243
定制操作 lambda表达式 一个lambda表达式表示一个可调用的代码单元，可以将其理解为一个未命名的内联函数 [capture list](parameter list)->return type {function body}//[capture list]和{function body}必不可少，其它可省略 ...
C++ Primer记录_第十章
ryacber的博客
04-20 913
C++Primer看书记录打卡
c++primer第五版习题答案（第10章）
11-12
c++primer第五版中文版课后答案（第10章）pdf格式，真正的c++primer习题集（第五版），用手机拍的，但是每个字都能看的很清楚
c++primer 第10章 泛型算法
最新发布
m0_68312479的博客
02-28 417
c++primer 第10章 泛型算法
c++primer——第十章泛型算法lambda
TinnCHEN的博客
03-25 283
一、谓词 谓词是一个调用表达式，其返回结果是一个能用做条件的值。 标准库算法为此分为两类： 1、一元谓词（意味着只能接受单一参数） 2、二元谓词（意味着他们有两个参数） 接受谓词的算法对输入序列中的元素调用谓词。因此元素类型必须能转换为谓词的参数类型。 以sort和isShorter举例 eg： bool isShorter(const string &s1, const string &...
C++ primer第十章答案
warmxixi的博客
04-03 516
14题 #include #include #include #include #include using namespace std; class Sales_data { public: Sales_data() = default; Sales_data(string s):_isbn(s){} string isbn() { return _isbn; } string _isbn; }...
C++PRIMER第十章课后练习
hubinyiyi的博客
10-19 624
10.1 #include #include #include using namespace std; int main() { vector vec{ 1,1,1,1,2,2,2 }; int n=count(vec.begin(), vec.end(), 1); cout return 0; } 10.2 #include #include #includ
自动类型转换auto
南的专栏
04-21 1233
在c++11中，你可以定一个变量
C++ Primer 答案 第十章
fly
11-16 744
10.1 and 10.2 #include &lt;iostream&gt; #include &lt;algorithm&gt; #include &lt;vector&gt; #include &lt;list&gt; using namespace std; int main(int argc, char *argv[]) {     vector&lt;int&gt; vec = ...
C++ Primer 第五版第十章习题答案
只为龙舞的博客
01-20 707
书籍版本：2019年9月第一版；王刚 杨巨峰译；电子工业出版社 编译器 ： win10  &amp;&amp; VS2015 10.1 #include "stdafx.h" #include &lt;iostream&gt; #include &lt;string&gt; #include &lt;vector&gt; #include &lt;list&gt; using namesp...
C++ primer plus 第六版 第十章 编程练习答案
菜鸡harry的博客
08-08 4255
第十章 编程练习答案 1. #ifndef ACCOUNT_H_ #define ACCOUNT_H_ //头文件 class BankAccount { private: std::string fullname; std::string account; double money; public: BankAccount(const std::str...
C++ Primer学习笔记：结构体与sizeof解析
"这篇学习笔记主要涵盖了C++ Primer的多个核心概念和技术，包括结构体、内存管理、数据类型对齐、标准输入输出、容器、泛型编程、面向对象编程、模板、异常处理、运行时类型识别以及一些特殊的语言特性。笔记深入浅...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值