第十章 STL

transform算法:用来做转换的

一元转化：是对容器给定范围内的所有元素做某种一元运算后放在另一个容器内。
有4个参数，前2个指定要转换容器的起止范围，第3个参数是结果存放容器的起始位置，第4个是一元运算
函数签名是;

template<class InputIterator,class OutputIterator,class UnaryFunction>
transform(InputIterator fisrt,Inputlterator last,OutputIterator result,UnaryFunction op){
  for(;first!=last;++first,++result){
    *result=op(*first);
    return result;
  }
}

具体例子

//从标准输入流中读取几个实数，分别将他们的平方和输出
#include<iostream>
#include<iterator>
#include<algorithm>
using namespace std;
double squre(double x) {
    return x * x;
}
int main() {
    transform(istream_iterator<double>(cin), istream_iterator<double>(), ostream_iterator<double>(cout, "\t"), squre);
    cout << endl;
    return 0;
}

二元转化：是对容器给定范围内的所有元素做某种二元运算后放在另一个容器内。
有5个参数，前2个指定要转换的第1个容器的起止范围，第3个参数是指定第2个要转换容器的开始位置（第一个容器的结束位置要小于等于第二个的结束位置），第5个是二元运算
函数签名是;

template<class InputIterator1,class InputIterator2,class OutputIterator,class BinartFunction>
transform(InputIterator1 fisrt1,Inputlterator1 last1,Inputlterator2 first1,OutputIterator result,BinartFunction op){

具体例子

//相加
#include<iostream>
#include<iterator>
#include<algorithm>
#include<vector>
using namespace std;
double add(double x,double y) {
    return (x+y);
}
int main() {
    vector<double>s1 = { 1,2,3 };
    transform(istream_iterator<double>(cin), istream_iterator<double>(), s1.begin(),ostream_iterator<double>(cout, "\t"), add);
    cout << endl;
    return 0;
}

综合运用几种迭代器

#include<algorithm>
#include<iostream>
#include<iterator>
#include<vector>
using namespace std;
//mysort算法进行排序
template<class T, class InputIterator, class OutputIterator>
void mySort(InputIterator first, InputIterator last, OutputIterator result) {
    vector<T>s;
    for (; first != last; ++first)
        s.push_back(*first);
    sort(s.begin(), s.end());
    copy(s.begin(), s.end(), result);
}
int main() {
    double a[5] = { 1.2, 2.4, 0.8, 3.3, 3.2 };
    //函数模板可以显示声明模板参数
    mySort<double>(a, a + 5, ostream_iterator<double>(cout," "));
    cout << endl;
    //从标准输入流读取若干整数，将排序后的结果输出
    mySort<int>(istream_iterator<int>(cin), istream_iterator<int>(), ostream_iterator<int>(cout, " "));
    cout << endl;
    return 0;
}
}

容器
https://blog.csdn.net/weixin_43691058/article/details/88556471

#include<iostream>
#include<list>
#include<deque>//双端队列
#include <iterator>
using namespace std;
template<class T>
void printContainer(const char* msg, const T& s) {
    cout << msg << ":";
    copy(s.begin(), s.end(), ostream_iterator<int>(cout, " "));
    cout<<endl;
}
int main() {
    deque<int>s;
    for (int i = 0; i < 10; i++) {
        int x;
        cin >> x;
        //s.push_front()//头插
        s.push_back(x);//尾插
    }
    printContainer("deque at first",s);
    list<int>l(s.rbegin(), s.rend());
    printContainer("list at first", l);
    //声明指向list<int>的迭代器
    list<int>::iterator iter = l.begin();
    while (iter != l.end()) {
        int v = *iter;
        iter = l.erase(iter);//删除当前元素，返回值是被删除的当前元素的下一个元素，例如9 0 删除9后返回值指向0
        l.insert(++iter, v);//在当前元素的后一个位置插入被删除的元素 0 后面插入9
    }
    printContainer("list at last", l);
    s.assign(l.begin(), l.end());//赋值
    printContainer("deque at last", s);
    return 0;

}

向量vector

特点

  • 一个可扩展的动态数组
  • 随机访问、尾部插入和删除元素较快
  • 在中间和头部插入和删除慢

双端队列deque

特点

  • 两端插入和删除元素快
  • 中间插入和删除元素慢
  • 随机访问较快，但比向量的慢( s[],S容器类型)
//双端队列队列
#include<iostream>
#include<deque>
#include<vector>//双端队列

#include <iterator>
#include<algorithm>
using namespace std;
int main() {
    istream_iterator<int>i1(cin), i2;//输入流迭代器 i1起始位置 i2终点
    vector<int>s1(i1, i2);//通过输入流迭代器构建vector容器
    sort(s1.begin(), s1.end());//排序算法，将该容器内的元素进行排序
    deque<int>s2;
    //从大到小输出奇数，从小到大输出偶数
    for (vector<int>::iterator iter = s1.begin(); iter != s1.end(); ++iter) {
        if (*iter % 2 == 0)
            s2.push_back(*iter);
        else
            s2.push_front(*iter);
    }
    //将s2的结果输出 ctr1+z表示输入结束
    copy(s2.begin(), s2.end(), ostream_iterator<int>(cout, " "));
    cout << endl;
    return 0;

}

列表

特点

  • 在任意位置插入和删除元素都比较快
  • 不支持随机访问
    接合（splice）操作
    s1.splice(p,s2,q1,q2);//将s2中的[q1,q2)移动到s1的p所指向的元素之前之前
    //p q1 q2都是迭代器 s1和s2是列表
    注意是移动元素，而不是拷贝一份副本到被接合的容器中，移动后s1和s2中的元素都发生了变化
#include<iostream>
#include<list>
#include<string>
#include <iterator>
#include<algorithm>
using namespace std;
int main() {
    string name1[] = { "Alice", "Helen","Lucy","Susan" };
    string name2[] = { "Bob","David","Levin","Mike" };
    list<string>s1(name1, name1 + 4);//左闭右开
    list<string>s2(name2, name2 + 4);
    //将s1的第一个元素放到s2之后
    s2.splice(s2.end(), s1, s1.begin());//元素移动
    list<string>::iterator iter1 = s1.begin();
    advance(iter1, 2);//前进两个位置
    list<string>::iterator iter2 = s2.begin();
    ++iter2;
    list<string>::iterator iter3 = iter2;
    advance(iter3, 2);
    s1.splice(iter1, s2, iter2, iter3);
    copy(s1.begin(), s1.end(), ostream_iterator<string>(cout, " "));
    cout << endl;
    copy(s2.begin(), s2.end(), ostream_iterator<string>(cout, " "));
    cout << endl;
}

set

#include<iostream>
#include<set>
#include<string>
#include<iterator>
#include<utility>//pair make_pair
using namespace std;
int main() {
    set<double>s;
    while (true) {
        double v;
        cin >> v;
        if (v == 0) {
            break;
        }
        pair < set<double>::iterator, bool > t = s.insert(v);
        if (!t.second) {
            cout << v << "is duplicated" << endl;
        }
    }
        set<double>::iterator iter1 = s.begin();
        set<double>::iterator iter2 = s.end();
        double medium = (*iter1 + *(--iter2)) / 2;//容器都是左闭右开，最后一个元素是end前面一个元素
        copy(s.begin(), s.upper_bound(medium), ostream_iterator<double>(cout, " "));//upper_bound(val)第一个大于val的元素的位置迭代器
        copy(s.lower_bound(medium), s.end(), ostream_iterator<double>(cout, " "));//lower_bound(val)第一个大于等于val的元素位置迭代器
    
}

map

#include<iostream>
#include<map>
#include<string>
#include<utility>//pair make_pair
using namespace std;
int main() {
    map<string, int>courses;
    //三种不同的插入方式
    courses.insert(make_pair("C++", 2));
    courses["OS"] = 5;
    courses.insert(pair<string, int>("COMPILER", 4));
    int n = 3;
    int sum = 0;
    while (n) {
        string name;
        cin >> name;
        map<string, int>::iterator iter = courses.find(name);//键值作为关键字
        if (iter == courses.end()) {
            cout << name << " is not available" << endl;
        }
        else {
            sum += iter->second;
            courses.erase(iter);
            n--;
        }
    }
    cout << "Total credit" << sum << endl;
    return 0;
}

multimap

#include<iostream>
#include<map>
#include<string>
#include<iterator>
#include<utility>//pair make_pair
using namespace std;
int main() {
    multimap<string, string>courses;
    typedef multimap<string, string>::iterator CourseIter;
    courses.insert(make_pair("a", "1-1"));
    courses.insert(make_pair("b", "2-1"));
    courses.insert(make_pair("b", "2-1"));
    courses.insert(make_pair("a", "3-1"));
    courses.insert(make_pair("a", "4-1"));
    string name;
    
    int count;
    do {
        cin >> name;
        count = courses.count(name);//count返回值是一个int类型表示出现次数，find返回值是一个指向出现位置的迭代器
        if (count == 0)
            cout << "cannot find this course" << endl;
    } while (count == 0);
    cout << count << "per week" << endl;
//两种方法都是等效的，equal_range=[lower_bound,upper_bound)
    //pair<CourseIter, CourseIter>range = courses.equal_range(name);
    multimap<string, string>::iterator iter1 = courses.lower_bound(name);
    multimap<string, string>::iterator iter2 = courses.upper_bound(name);
    //for (CourseIter iter1 = range.first; iter1 != range.second; ++iter1)  
    for (; iter1 != iter2; ++iter1)
        cout << iter1->second << " ";
    cout << endl;
    return 0;
}

函数对象

行为类似于函数的对象
https://www.cnblogs.com/lzy820260594/p/11398661.html

函数适配器（函数对象的适配器）

image.png
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容