stl 容器适配器、迭代器适配器和函数适配器讲解

最新推荐文章于 2024-07-23 21:04:13 发布

weixin_34348174

最新推荐文章于 2024-07-23 21:04:13 发布

阅读量183

点赞数

文章标签： c/c++ 前端 ViewUI

原文链接：https://my.oschina.net/lmoon/blog/872219

版权

为什么80%的码农都做不了架构师？>>>

一、迭代器

list的迭代器不支持算术运算，也不支持关系运算符(<=,<,>=,>),他只提供前置和后置的自增、自减以及相等和不相等运算。list的内存不连续。

vector和deque容器的迭代器是一种类型，vector能做的DEQUE也可以。

二、容器适配器

queue,priority_queue,stack.

默认的queue和stack实在deque基础上实现，而PRIORITY_QUEUE则是在vector基础上实现。

queue需要提供PUSH_FRONT函数，只能由deque和list初始化。

stack可以由vector,deque,list初始化。

priority_queue需要提供随即访问功能，由vector和deque初始化。

在优先队列中，优先级高的元素先出队列。
标准库默认使用元素类型的<操作符来确定它们之间的优先级关系。
优先队列的第一种用法，也是最常用的用法：

priority_queue<int> qi;

通过<操作符可知在整数中元素大的优先级高。
故示例1中输出结果为：9 6 5 3 2

第二种方法：
在示例1中，如果我们要把元素从小到大输出怎么办呢？
这时我们可以传入一个比较函数，使用functional.h函数对象作为比较函数。

priority_queue<int, vector<int>, greater<int> >qi2;

其中
第二个参数为容器类型。
第二个参数为比较函数。greater是内部函数，也可以less
故示例2中输出结果为：2 3 5 6 9

第三种方法：
自定义优先级。

struct node
{
     friend bool operator< (node n1, node n2)
     {
         return n1.priority < n2.priority;
     }
     int priority;
     int value;
};

在该结构中，value为值，priority为优先级。
通过自定义operator<操作符来比较元素中的优先级。
在示例3中输出结果为：
优先级  值
9         5
8         2
6          1
2          3
1          4
但如果结构定义如下：

struct node
{
     friend bool operator> (node n1, node n2)
     {
         return n1.priority > n2.priority;
     }
     int priority;
     int value;
};

则会编译不过（G++编译器）
因为标准库默认使用元素类型的<操作符来确定它们之间的优先级关系。
而且自定义类型的<操作符与>操作符并无直接联系，故会编译不过。

//代码清单

#include<iostream>
#include<functional>
#include<queue>
using namespace std;
struct node
{
     friend bool operator< (node n1, node n2)
     {
         return n1.priority < n2.priority;
     }
     int priority;
     int value;
};
int main()
{
     const int len = 5;
     int i;
     int a[len] = {3,5,9,6,2};
     //示例1
     priority_queue<int> qi;
     for(i = 0; i < len; i++)
         qi.push(a[i]);
     for(i = 0; i < len; i++)
     {
         cout<<qi.top()<<" ";
         qi.pop();
     }
     cout<<endl;
     //示例2
     priority_queue<int, vector<int>, greater<int> >qi2;
     for(i = 0; i < len; i++)
         qi2.push(a[i]);
     for(i = 0; i < len; i++)
     {
         cout<<qi2.top()<<" ";
         qi2.pop();
     }
     cout<<endl;
     //示例3
     priority_queue<node> qn;
     node b[len];
     b[0].priority = 6; b[0].value = 1;
     b[1].priority = 9; b[1].value = 5;
     b[2].priority = 2; b[2].value = 3;
     b[3].priority = 8; b[3].value = 2;
     b[4].priority = 1; b[4].value = 4;

     for(i = 0; i < len; i++)
         qn.push(b[i]);
     cout<<"优先级"<<'\t'<<"值"<<endl;
     for(i = 0; i < len; i++)
     {
         cout<<qn.top().priority<<'\t'<<qn.top().value<<endl;
         qn.pop();
     }
     return 0;
}

C++之函数适配器

C++定义了一些特殊的函数适配器(Function adapters)，通过这些函数适配器我们可以将预先定义的仿函数和其他数值结合在一起或使用特殊情况。

上例子吧：

void testAdapter()
{
std::set<int,std::greater<int> > intSet;
std::deque<int> intDeque;

    for(int i=1;i<10;++i)
        intSet.insert(i);
    std::cout<<"Initialized Set:\n";
    copy(intSet.begin(),intSet.end(),
         std::ostream_iterator<int>(std::cout," "));
    transform(intSet.begin(),intSet.end(),
              back_inserter(intDeque),
             bind2nd(std::multiplies<int>(),10)); ///operation
    std::cout<<"\nDeque data:\n";
    copy(intDeque.begin(),intDeque.end(),
         std::ostream_iterator<int>(std::cout," "));

    replace_if(intDeque.begin(),intDeque.end(),
               bind2nd(std::equal_to<int>(),70), ///operation
               0);
    std::cout<<"\nDeque data after replace:\n";
    copy(intDeque.begin(),intDeque.end(),
         std::ostream_iterator<int>(std::cout," "));
    intDeque.erase(remove_if(intDeque.begin(),intDeque.end(),
                             bind2nd(std::less<int>(),50)),
                   intDeque.end());
    std::cout<<"\nDeque data after erase:\n";
    copy(intDeque.begin(),intDeque.end(),
         std::ostream_iterator<int>(std::cout," "));
}

函数适配器bind2nd的工作原理：

以    transform(intSet.begin(),intSet.end(),
              back_inserter(intDeque),
              bind2nd(std::multiplies<int>(),10)); ///operation

为例吧：

   transform()希望自己的第四个参数是一个能接纳单一参数(即容器实际元素)的表达式,
   然后我们希望先将元素乘以10再传给transform(),
   所有我们必须购置一个表达式，接受两个参数，并以数值10作为第二个参数
   以此产生一个只接受一个参数的表达式

   bind2nd会把表达式保存起来，将第二个参数当内部数值保存起来
   当算法以实际集群元素为参数，调用bind2nd时，bind2nd将元素作为第一参数
   把原先保存下来的数值作为第二个参数，调用保留下来的表达式，并返回调用结果

详见《源源码剖析》第8章

另外，某些仿函数可以用来调用集群内每个元素的成员函数：
for_each(intDeque.begin(),intDeque.end(),
mem_fun_ref(&Person::printInfo()))
仿函数mem_fun_ref将调用它所作用的每个元素的某个成员函数
当然，必须保证这些元素的类型是Person或者Person的派生类，
并且可以printInfo()函数

STL的stack适配器函数

c.push(const value_type&v)	将v压入到栈中
c.pop()	移除栈顶元素
c.top()	返回栈顶元素
c.empty()	栈空时返回true
c.size()	返回栈中的元素个数
== 和 <	判等运算符和按字典顺序计算的小于运算符

STL的queue适配器函数

c.push(const value_type&v)	将v放到队列尾部
c.pop()	从队列前端移除元素
c.front()	返回队列前端元素
c.back()	返回队列尾部元素
c.empty()	队列空时返回true
c.size()	返回队列的元素个数
== 和 <	判等运算符和按字典顺序计算的小于运算符