STL——前闭后开区间表示法和function call 操作符

前开后闭开区间表示法[)

任何一个STL算法,都需要获得由一对迭代器(泛型指针)所标示的区间,用以表示操作范围,这一对迭代器所标示的是个所谓的前闭后开区间,以[first,last)表示,也就是说,整个实际范围从first开始,直到last-1.迭代器last所指的是“最后一个元素的下一位置”。这种off by one(偏移一格,或说pass the end)的标示法,带来了很多方便,例如下面两个STL算法的循环设计,就显得干净利落:

template<class InputIterator,class T>
InputIterator find(InputIterator first,InputIterator last,const T&value)
{
    while(first!=last&&*first!=value) ++first;
    return first; //返回迭代器
}

template <class InputIterator,class Function>
Function for_each(InputIterator first,InputIterator last,Function f)
{
    for(;first!=last;++first)
        f(*first);
    return f;
}

  前闭后开区间示意图如下(注意,元素之间无需占用连续内存空间):

function call 操作符

函数调用操作(C++语法中的左右小括号)也可以被重载。

许多STL算法都提供了两个版本,一个用于一般情况(例如排序时以递增方式排列),一个用于特殊情况(例如排序时由使用者指定以何种特殊关系进行排列),像这种情况,需要用户指定某个条件或某个策略,而条件或策略的背后由一整组操作构成,便需要某种特殊的东西来代表这“一整组操作”。

代表“一整组操作“的,当然是函数,过去C语言时代,欲将函数当做参数传递,唯有通过函数指针才能达成,例如:

#include<iostream>
#include<cstdlib>
using namespace std;

int fcmp(const void* elem1,const void* elem2);

int main()
{
    int ia[10]={32,92,67,58,10,4,25,52,59,54};
    for(int i=0;i<10;i++)
        cout<<ia[i]<<" ";
    cout<<endl;
    qsort(ia,sizeof(ia)/sizeof(int),sizeof(int),fcmp);

    for(int i=0;i<10;i++)
        cout<<ia[i]<<" ";
    cout<<endl;
}

int fcmp(const void* elem1,const void* elem2)
{
    const int *i1=(const int*)elem1;
    const int *i2=(const int*)elem2;
    if(*i1<*i2)
        return -1;
    else if(*i1==*i2)
        return 0;
    else if(*i1>*i2)
        return 1;
}

  运行结果:

但是函数指针有缺点,最重要的是它无法持有自己的状态(所谓局部状态,local states),也无法达到组件技术中的可适配性(adaptability)——也就是无法再将某些修饰条件加诸于其上面而改变其状态

qsort函数:
功 能: 使用快速排序例程进行排序
头文件:stdlib.h
用 法: void qsort(void *base,int nelem,int width,int (*fcmp)(const void *,const void *));
参数: 1 待排序数组首地址
2 数组中待排序元素数量
3 各元素的占用空间大小
4 指向函数的指针,用于确定排序的顺序

为此,STL算法的特殊版本所接受的所谓“条件”或“策略”或“一整组操作”,都以仿函数形式呈现。所谓仿函数(functor)就是使用起来像函数一样的东西。如果你针对么某个class进行operator()重载,它就是一个仿函数,至于要成为一个可配接的仿函数,还需要做一些额外的努力。

#include<iostream>
//注意,不能使用using namespace std 不然plus和minus会有歧义
using std::cout;
using std::endl;

template <class T>
struct plus
{
    T operator()(const T& x,const T& y) const {return x+y;}
};

template <class T>
struct minus
{
    T operator()(const T& x,const T& y)const {return x-y;}
};

int main()
{
    plus<int> plusObj;
    minus<int> minusObj;
    cout<<plusObj(3,5)<<endl;
    cout<<minusObj(3,5)<<endl;
    //注意下面的调用,不要忘记调用默认构造函数的小括号以及函数对象调用参数的小括号  //以下直接产生仿函数的临时对象(第一对小括号),并调用之(第二对小括号)
    cout<<plus<int>()(43,50)<<endl;
    cout<<minus<int>()(43,50)<<endl;
}

运行结果:

  

时间: 2024-11-05 12:16:04

STL——前闭后开区间表示法和function call 操作符的相关文章

前闭后开区间表示法

 任何一个STL算法,都需要获得由一对迭代器(泛型指针)所标识的区间,用以表示操作范围.这一对迭代器所标示的是个所谓的前闭后开区间,以[first,last)表示.也就是说,整个实际范围从first开始,知道last-1.迭代器last所指的是"最后一个元素的下一位置".这种偏移一格的标示法,带来了许多方便,例如下面两个STL算法的循环设计,就显得干净利落: template <class InputIterator,classT> InputIterator find

前闭后开区间

任何一个STL算法,都需要获得由一对迭代器(泛型指针)所标识的区间,用以表示操作范围.这一对迭代器所标示的是个所谓的前闭后开区间,以[first,last)表示.也就是说,整个实际范围从first开始,知道last-1.迭代器last所指的是“最后一个元素的下一位置”.这种偏移一格的标示法,带来了许多方便,例如下面两个STL算法的循环设计,就显得干净利落: 1 template <class InputIterator,classT> 2 3 InputIterator find(InputI

js 获取当前日期或者前、后N天yyyy-MM-dd的方法

//js获取当前日期.当前日期前.后N天的标准年月日 //day=0为当前天,day=7为前7天,day=-7为当前日期的后7天 function getstartdate(day) {            var beginDate;            var curr_time = new Date();            var week_time = new Date(curr_time.getTime() - 1000 * 60 * 60 * 24 * day);      

main函数执行前、后再执行的代码

一.main结束 不代表整个进程结束  (1)全局对象的构造函数会在main 函数之前执行,          全局对象的析构函数会在main函数之后执行:          用atexit注册的函数也会在main之后执行.  (2)一些全局变量.全局对象和静态变量.对象的空间分配和赋初值就是在执行main函数之前,而main函数执行完后,还要去执行一些诸如释放空间.释放资源使用权等操作  (3)进程启动后,要执行一些初始化代码(如设置环境变量等),然后跳转到main执行.全局对象的构造也在ma

二叉树的前中后序遍历简单的递归

二叉树的遍历 无外乎广度和深度 其中深度又分为前中后序遍历三种情况  这三种遍历若只是递归方法 自然很是简单 但递归代码简单 若嵌套层次太深 会栈溢出 二叉树节点数据结构: struct Binary_node{    int val;    Binary_node *left;    Binary_node *right;    Binary_node(int v = 0, Binary_node *le = nullptr, Binary_node *ri = nullptr) :val(v

HMM 前向后向算法(转)

最近研究NLP颇感兴趣,但由于比较懒,所以只好找来网上别人的比较好的博客,备份一下,也方便自己以后方便查找(其实,一般是不会再回过头来看的,嘿嘿 -_-!!) 代码自己重新写了一遍,所以就不把原文代码贴过来了. 1. 前向算法(摘自http://www.cnblogs.com/kaituorensheng/archive/2012/12/01/2797230.html) 隐马模型的评估问题即,在已知一个观察序列O=O1O2...OT,和模型μ=(A,B,π}的条件下,观察序列O的概率,即P(O|

隐马尔科夫模型HMM(二)前向后向算法评估观察序列概率

隐马尔科夫模型HMM(一)HMM模型 隐马尔科夫模型HMM(二)前向后向算法评估观察序列概率 隐马尔科夫模型HMM(三)鲍姆-韦尔奇算法求解HMM参数(TODO) 隐马尔科夫模型HMM(四)维特比算法解码隐藏状态序列(TODO) 在隐马尔科夫模型HMM(一)HMM模型中,我们讲到了HMM模型的基础知识和HMM的三个基本问题,本篇我们就关注于HMM第一个基本问题的解决方法,即已知模型和观测序列,求观测序列出现的概率. 1. 回顾HMM问题一:求观测序列的概率 首先我们回顾下HMM模型的问题一.这个

隐马尔可夫模型(七)——隐马尔可夫模型的学习问题(前向后向算法)(转载)

隐马尔可夫模型的学习问题:给定一个输出序列O=O1O2...OT,如何调节模型μ=(A,B,π)的参数,使得P(O|M)最大. 最大似然估计是一种解决方法,如果产生的状态序列为Q=q1q2...qT,根据最大似然估计,可以通过以下公式推算: πi' = δ(q1,si) aij' =  Q中从状态qi转移到qj的次数/Q中从状态qi转移到另一状态(包括qj)的次数 bj(k)' = Q中从状态qj发出符号Vk的次数/ Q中到达状态qj的次数 δ(x,y)为克罗奈克函数,当x=y时,δ(x,y)=

非递归前中后序遍历二叉树

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 写在前面: 最近准备找工作,捡起原来学习过的各种知识,加上一些自己的理解,梳理一下流程,巩固自己的认识,一步两步,一步两步... ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 二叉树的遍历是树操作的基础,一般的前中后序递归遍历比较简单,这里就不列出了,主要是非递归实