c++ 进阶 泛型编程

1 . 泛型算法概述

每个泛型算法的实现都独立于单独的容器类型 因为已经消除了算法的类型依赖性 所
以单个的模板实例可以操作在各种容器以及内置数组类型上 考虑 find()算法 因为它独立
于被适用的容器 所以它只要求下列一般性的步骤 这里假设资料集合未经排序
1 顺次检查每个元素
2 如果当前元素等于要被查找的值 那么返回该元素在集合中的位置
3 否则 检查下一个元素 重复步骤 2 直到找到一个元素 或者检查完所有元素
4 如果已经到了集合的末尾 而且还没有找到该值 则返回某个值指明该值在这个集合
中不存在
或 0

迭代器算法不依赖于一容器，但是依赖于元素类型操作。

2 . 只读算法（const）

1.accumulate函数:求和函数

include <\numeric>
三个参数：第一二个为求和范围，第三个参数求和初值 。
int sum = accumulate(vec.begin(),vec.end(),0);

2.equal函数:判断两个序列是否保存相同的值，

equal（v.cbegin（），v.cend（），v_.cbegin（）） 前两参数表示序列一范围，第三个参数表示序列起始位置，
提醒：假设第二个序列长度不小于第一个序列。

3. 写容器算法（const）

1.fill函数与fill_n函数，后者不做安全检查

fill（vec.begin(),vec.end(),0），所有元素重置为0
fill_n（dest，n，val）

2.back_insert() 插入迭代器,返回一个与该容器绑定的插入迭代器

fill_n(back_insert(vec),10,0) 添加10个元素到vec

3.拷贝操作：copy 返回其目的位置迭代器之后

auto ret =copy(begin(a1),begin(a2),a2),ret z指向拷贝到a2的尾元素之后的位置。

很多算法都提供所谓的拷贝版本，这些算法计算新元素的值，点不会将他们放置在输入系列的末尾，而是创建一个新系列保存这些结果。

replace（list.begin（），list.end（），0,42）将0，改换成42；
希望保持原序列不变，提供replace_copy 接受第三个迭代器参数，保存调整后的序列位置。

replace_copy（list.begin（），list.end（），back_inserte（vec）r，0,42），vec将保存copy的list

4.容器重排：sort，消除重复单词 unique 删除元素 erase

unique（消除后容器大小没变，只是将相邻重复的元素消除，指向一个不重复值范围的末尾）

一个总的测试程序：

test.1


#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <numeric>
#include <list>
int main()
{
    std::vector<int> v = { 1, 2, 3, 4, 5, 6, 6, 6, 2 };
    std::cout << "ex 10.01: " << std::count(v.cbegin(), v.cend(), 6) << std::endl;

    // 10.2
    std::list<std::string> l = { "aa", "aaa", "aa", "cc" };
    std::cout << "ex 10.02: " << std::count(l.cbegin(), l.cend(), "aa") << std::endl;

    // Exercise 10.3
    std::vector<int> vc= { 1, 2, 3, 4 };
    std::cout << "ex 10.03: " << std::accumulate(vc.cbegin(), vc.cend(), 0) << std::endl;

    // Exercise 10.4
    std::vector<double> vd = { 1.1, 0.5, 3.3 };
    std::cout << "ex 10.04: "
        << std::accumulate(vd.cbegin(), vd.cend(), 0) //0是整型  注意 结果被截取
        << std::endl;                       
    return 0;
}
output:3  2  10 4

test2

#include <iostream>
#include <vector>
#include <list>
#include <algorithm>

using std::vector; using std::cout; using std::endl; using std::list; using std::cin; using std::fill_n;

template<typename Sequence>
void print(Sequence const& seq)
{
    for (const auto& i : seq)
        cout << i << " ";
    cout << endl;
}

int main()
{
    // (a)
    vector<int> vec;
    list<int> lst;
    int i;
    while (cin >> i)
        lst.push_back(i);
    vec.resize(lst.size());
    // ^ Fixed: added this statement
    // Cause Algorithms that write to a destination iterator assume
    // the destination is large enough to hold the number of elements being written.
    copy(lst.cbegin(), lst.cend(), vec.begin());

    // (b)
    vector<int> v;
    v.reserve(10);
    fill_n(v.begin(), 10, 0);//运行错误，原因读者好好理解


    print(v);
    print(vec);
}

删除重复文本demo

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

// print containers like vector, deque, list, etc.
template<typename Sequence>
auto println(Sequence const& seq) -> std::ostream&
{
    for (auto const& elem : seq) 
        std::cout << elem << " ";
    return std::cout << std::endl;
}

auto eliminate_duplicates(std::vector<std::string> &vs) -> std::vector<std::string>&
{
    std::sort(vs.begin(), vs.end());
    println(vs);

    auto new_end = std::unique(vs.begin(), vs.end());
    println(vs);

    vs.erase(new_end, vs.end());
    return vs;
}

int main()
{
    std::vector<std::string> vs{ "a", "v", "a", "s", "v", "a", "a" };
    println(vs);
    println(eliminate_duplicates(vs));

    return 0;
}