STL区间成员函数及区间算法总结

在这里总结下可替代循环的区间成员函数和区间算法;

相比单元素遍历操作,使用区间成员函数的优势在于:
1)更少的函数调用
2)更少的元素移动
3)更少的内存分配

在区间成员函数不适用的情况下也应该使用区间算法,至少,相比手写循环而言,它更加简单,有效,并且不容易出错;

区间成员函数

区间构造

标准容器都支持区间构造函数:

代码如下:

container::container(InputIterator begin, // 区间的起点
                  InputIterator end); // 区间的终点

例如:

代码如下:

int myints[] = { 10, 20, 30, 30, 20, 10, 10, 20 };
std::vector<int> myvector (myints, myints+8);

以上是c++98中常用法,在C++11中,vector可以直接初始化了:

代码如下:

std::vector<int> second ={10, 20, 30, 30, 20, 10, 10, 20};

或者:

代码如下:

std::vector<int> second ({10, 20, 30, 30, 20, 10, 10, 20});

区间插入

标准序列容器提供这种形式的insert:

代码如下:

void container::insert(iterator position, // 区间插入的位置
                    InputIterator begin, // 插入区间的起点
                    InputIterator end); // 插入区间的终点

例如:

代码如下:

int myints[] = { 10, 20, 30, 30, 20, 10, 10, 20 };
std::vector<int> myvector;
myvector.push_back(100);
myvector.insert(myvector.begin(),myints,myints+8); //10 20 30 30 20 10 10 20 100

关联容器也支持区间插入,但由于其插入后的位置由其比较函数来决定,所以没有区间插入的位置这个参数;

区间删除

标准序列容器提供的erase:

iterator container::erase(iterator begin, iterator end);

c++98的标准关联容器提供的erase为:

void container::erase(iterator begin, iterator end);

序列容器调用erase之后,返回一个迭代器(被删除的那个元素的下一个),
而关联容器的erase删除之后并不返回迭代器.【官方解释说如果实现成序列容器那样返回指向下一个迭代器,会导致无法接收的性能下降】;

这一区别在c++11中终于统一了;c++11中,对关联容器调用erase之后会返回一个迭代器(指向被删除元素的下一个);

iterator container::erase(const_iterator first, const_iterator last);

区间赋值

所有标准容器提供了区间赋值的成员函数:

void container::assign(InputIterator begin, InputIterator end);
这个函数用于给容器赋值,会替代现有值,并根据需要分配空间;
与copy()算法的区别在于它不需要预先分配空间,并有更高的性能;

代码如下:

int myints[]={10,20,30,40,50,60,70};
std::vector<int> myvector;
myvector.assign(myints,myints+7);

通用区间算法

for_each 区间迭代

for_each:遍历,对每个元素都执行一个动作;
C++98只支持最原始的for循环,很多语言(java、python等)都实现了foreach区间迭代语法,这让C++程序员眼馋了很久;
在没有foreach区间迭代的时代,我们可以用for_each()算法来代替:

例:对每个元素都加5:

代码如下:

void myfunction (int& i) {
    i += 5;
}
std::vector<int> myvector;
myvector.push_back(10);
myvector.push_back(20);
myvector.push_back(30);
for_each(myvector.begin(),myvector.end(),myfunction); //15 25 35

c++11中新增了区间迭代,使得我们对for_each的依赖降低了,使用也更加方便:

代码如下:

for(auto &i : myvector )
{
    i+=5;
}

transform() 区间迭代后新值另存为其它地方

对区间中每个元素执行操作后,将修改后的值写入到新区间中;
可以认为这个是for_each()算法不修改原区间的版本;
还是for_each中的例子:

代码如下:

int addfunction(int i ){
    return i+5;
}
void output (int i) {  // output function
    std::cout << ' ' << i;
}
std::vector<int> myvector;
myvector.push_back(10);
myvector.push_back(20);
myvector.push_back(30);
std::vector<int> bvector;
bvector.resize(myvector.size());
transform(myvector.begin(),myvector.end(),bvector.begin(),addfunction);
//输出
for_each(bvector.begin(),bvector.end(),output); //bvector: 15 25 35

copy() 区间复制

区间复制,一般用于多个容器间的数据传值;
这个算法被用的很普遍,其实,很多使用copy的场景,都可以使用区间成员函数来替代(也建议这么做);

例:复制数组到vector:

代码如下:

int myints[]={10,20,30,40,50,60,70};
std::vector<int> myvector (7);
std::copy ( myints, myints+7, myvector.begin() );

fill() 区间填充

用一个元素来重复填充区间;
这个算法使用频率较低;
例:用5填充vector前4个元素:

代码如下:

std::vector<int> myvector (8);                       // myvector: 0 0 0 0 0 0 0 0
std::fill (myvector.begin(),myvector.begin()+4,5);   // myvector: 5 5 5 5 0 0 0 0

replace() 区间替换

遍历区间,进行值替换:
例:将以下区间中所有20替换为99:

代码如下:

int myints[] = { 10, 20, 30, 30, 20, 10, 10, 20 };
std::vector<int> myvector (myints, myints+8);            // 10 20 30 30 20 10 10 20
std::replace (myvector.begin(), myvector.end(), 20, 99); // 10 99 30 30 99 10 10 99

更复杂的版本(使用仿函数)replace_if
例:将以下区间中所有大于20替换为99:

代码如下:

bool bigerThen20 (int i) { return i > 20; }
int myints[] = { 10, 20, 30, 30, 20, 10, 10, 20 };
std::vector<int> myvector (myints, myints+8);            // 10 20 30 30 20 10 10 20
std::replace_if (myvector.begin(), myvector.end(), bigerThen20, 99); //10 20 99 99 20 10 10 20

由于用到了仿函数,通过replace_if实现的,用for_each()也很容易实现;

remove() 区间删除

从区间中删除指定元素;

代码如下:

int myints[] = { 10, 20, 30, 30, 20, 10, 10, 20 };
std::vector<int> myvector (myints, myints+8);            // 10 20 30 30 20 10 10 20
std::remove(myvector.begin(), myvector.end(), 20); // 10 30 30 10 10 ? ? ?

注意,remove并不会真正删除元素,而只是将需要删除的元素放到到最后,同时返回一个新的尾部迭代器,
比如,上述例子中,调用完remove后,vector中的值一般为 //10 30 30 10 10 10 10 20
而如果希望真的删除元素,需要加上成员函数erase()来实现删除 【remove-erase惯用法】:

代码如下:

myvector.erase(std::remove(myvector.begin(), myvector.end(), 20),myvector.end()); // 10 30 30 10 10

unique() 区间去重

从区间中删除相邻相同的元素,同样,这个算法也不会真正的删除元素,而是将待删除的元素移到区间尾部;
使用【unique-erase惯用法】:

代码如下:

int myints[] = {10,20,20,20,30,30,20,20,10};           // 10 20 20 20 30 30 20 20 10
std::vector<int> myvector (myints,myints+9);
std::vector<int>::iterator it;
it = std::unique (myvector.begin(), myvector.end());   // 10 20 30 20 10 ?  ?  ?  ?
myvector.erase(it,myvector.end());

以上所述就是本文的全部内容了,希望大家能够喜欢。

(0)

相关推荐

  • stl容器set,map,vector之erase用法与返回值详细解析

    总结本人在工作中经验教训. 在使用 list.set 或 map遍历删除某些元素时可以这样使用: 正确使用方法1 复制代码 代码如下: std::list< int> List;      std::list< int>::iterator itList;      for( itList = List.begin(); itList != List.end(); )      {            if( WillDelete( *itList) )            {

  • c++ STL容器总结之:vertor与list的应用

    STL提供六大组件,彼此可以组合套用 1.容器(containers):各种数据结构,如vertor,list,deque,set,map.从实现的角度来看,STL容器是一种class template 2.算法(algorithms):各种算法如sort,search,copy,earse.STL算法是一种 function template. 3.迭代器(iterators):扮演容器与算法之间的胶合剂,是所谓的"泛型指针".所有STL容器都有自己的专属的迭代器. 4.仿函数(fu

  • C++在成员函数中使用STL的find_if函数实例

    本文实例讲述了C++在成员函数中使用STL的find_if函数的方法.分享给大家供大家参考.具体方法分析如下: 一般来说,STL的find_if函数功能很强大,可以使用输入的函数替代等于操作符执行查找功能(这个网上有很多资料,我这里就不多说了). 比如查找一个数组中的奇数,可以用如下代码完成(具体参考这里:http://www.cplusplus.com/reference/algorithm/find_if/): #include <iostream> #include <algori

  • C++语言 STL容器list总结

    在使用std::list<>链表时,难免会对数据进行添加删除操作.而遍历链表则有两种方式:通过索引访问,象数组一样处理:通过std::list<>::iterator链表遍历器进行访问 STL 中的list 就是一 双向链表,可高效地进行插入删除元素. list不支持随机访问.所以没有 at(pos)和operator[]. list 对象list1, list2 分别有元素list1(1,2,3),list2(4,5,6) .list< int>::iterator

  • STL 的string类怎么啦

    STL 的string类怎么啦?陈皓 前言 上个周末在和我的同学爬香山闲聊时,同学说到STL中的string类曾经让他备受折磨,几年前他开发一个系统前对string类还比较清楚,然后随着程序的复杂度的加深,到了后期,他几乎对string类失去了信心和信任,他觉得他对string类一头雾水.老实说,我几年前也有同样的痛苦(就是当我写下<标准C++类string的Copy-On-Write技术>之前的一段时间).那时,我不得不研究那根本不是给人看的SGI出品的string类的源码,代码的可读性几乎

  • stl常用算法(Algorithms)介绍(stl排序算法、非变序型队列)

    算法:用来处理群集内的元素.它们可以出于不同的目的而搜寻,排序,修改,使用那些元素.是一种应用在容器上以各种方法处理其内存的行为或功能,如sort(排序),copy(拷贝)- 算法由模板函数体现,这些函数不是容器类的成员函数,是独立的函数,它们可以用于STL容器,也可以用于普通的C++数组等. 头文件:#include<algorithm> 在STL的泛型算法中有4类基本的算法: 1)变序型队列算法: 可以改变容器内的数据: 2)非变序型队列算法:处理容器内的数据而不改变他们: 3)排序值算法

  • C++ STL容器stack和queue详解

    stack是一个比较简单的容器,它的使用也很简单,stack是LIFO容器,就是后进先出,最后添加进去的元素,第一个取出来 stack初始化 std::stack<int> first; std::stack<int> second(first); std::stack<int, std;:vector<int>> third; //使用vector初始化stack ### stack常用方法### empty();//判断是否为空 push(Elem e)

  • jsp 使用jstl实现翻页实例代码

    使用jstl进行显示相对使用jsp来说代码更显得整齐,也使代码量显得较少 复制代码 代码如下: <%@page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%><%@taglib prefix="c"  uri = "http://java.sun.com/jsp/jstl/core"

  • c++非变易算法-stl算法

    C++ STL标准模板库在数据结构和算法的实践领域发挥着重要作用,极大的提高了开发效率.STL的三大组成部分为容器.迭代器.算法,本文主要讲解STL算法中的非变易算法.本文从实践的角度简单介绍了一下相关函数的使用. C++ STL的非变易算法(Non-mutating algorithms)是一组不破坏函数数据的模板函数,用来对序列数据进行逐个处理.元素查找.子序列搜索.统计和匹配,基本上可用于各种容器.下面的叙述中迭代器区间默认为[first, last),迭代器具有"++"迭代和&

  • STL区间成员函数及区间算法总结

    在这里总结下可替代循环的区间成员函数和区间算法: 相比单元素遍历操作,使用区间成员函数的优势在于: 1)更少的函数调用 2)更少的元素移动 3)更少的内存分配 在区间成员函数不适用的情况下也应该使用区间算法,至少,相比手写循环而言,它更加简单,有效,并且不容易出错: 区间成员函数 区间构造 标准容器都支持区间构造函数: 复制代码 代码如下: container::container(InputIterator begin, // 区间的起点                   InputIter

  • C++:函数对象,STL提供的函数对象,函数适配器详解

    目录 1 函数对象 2 STL提供的函数对象 3 函数适配器 总结 1 函数对象 1.函数对象是行为类似函数的对象.一个类对象,表现出一个函数的特征,即通过对象名+(参数列表)的方式使用一个类对象. 2.使用STL中提供的或自定义的迭代器和**函数对象,**配合STL的算法,组合出各种各样的功能. 3.通过函数对象而不使用函数指针,可以增加通用性,提高效率. 4.函数对象概念:泛化的函数 ①将普通函数作为函数对象:传递函数名 #include <iostream> #include <n

  • C++的STL中accumulate函数的使用方法

    目录 1.累加求和 2.自定义数据类型的处理 3.用法 前言: accumulate定义在#include中,作用有两个,一个是累加求和,另一个是自定义类型数据的处理 1.累加求和 int sum = accumulate(vec.begin() , vec.end() , 42); accumulate带有三个形参:头两个形参指定要累加的元素范围,第三个形参则是累加的初值.accumulate函数将它的一个内部变量设置为指定的初始值,然后在此初值上累加输入范围内所有元素的值.accumulat

  • python利用dir函数查看类中所有成员函数示例代码

    前言 如果一个类是别人编写的,又没有帮助文档,怎么样来查看所有成员函数呢?本文详细给大家介绍了关于python用dir函数查看类中所有成员函数的相关内容,下面话不多说了,来一起看看详细的介绍吧. 可以使用下面的代码: # File: builtin-dir-example-2.py class A: def a(self): pass def b(self): pass class B(A): def c(self): pass def d(self): pass def getmembers(

  • PHP中strnatcmp()函数“自然排序算法”进行字符串比较用法分析(对比strcmp函数)

    本文实例讲述了PHP中strnatcmp()函数"自然排序算法"进行字符串比较用法.分享给大家供大家参考,具体如下: PHP中strnatcmp()函数使用"自然"算法来比较两个字符串(区分大小写),通常在自然算法中,数字 2 小于数字 10.而在计算机排序中,10 小于 2,这是因为 10 中的第一个数字小于 2. strnatcmp()函数的定义如下: strnatcmp(string1,string2) 参数说明: string1  必需.规定要比较的第一个字

  • C++ 中const对象与const成员函数的实例详解

    C++ 中const对象与const成员函数的实例详解 const对象只能调用const成员函数: #include<iostream> using namespace std; class A { public: void fun()const { cout<<"const 成员函数!"<<endl; } void fun() { cout<<"非const成员函数 !"<<endl; } }; int

  • 一般函数指针和类的成员函数指针深入解析

    函数指针是通过指向函数的指针间接调用函数.函数指针可以实现对参数类型.参数顺序.返回值都相同的函数进行封装,是多态的一种实现方式.由于类的非静态成员函数中有一个隐形的this指针,因此,类的成员函数的指针和一般函数的指针的表现形式不一样. 1.指向一般函数的指针函数指针的声明中就包括了函数的参数类型.顺序和返回值,只能把相匹配的函数地址赋值给函数指针.为了封装同类型的函数,可以把函数指针作为通用接口函数的参数,并通过函数指针来间接调用所封装的函数.下面是一个指向函数的指针使用的例子. 复制代码

  • C++常量详解二(常量形参,常量返回值,常量成员函数)

    1.常量形参 当形参有顶层const或者底层const的时候,传给它常量对象或者非常量对象都是可以的,在这里我们主要考虑形参无const, 而实参有const的情况,其实这里也十分简单,只需要记住一点:底层const的限制,就可以了. 2.常量返回值 这里也很简单,略过不提. 3.常量成员函数 常量函数里的const是用来修饰*this的,其形式如下: int f() const{```} 然后这里就有意思了 *this的默认类型是type *const this,this指针有一个顶层cons

  • C++中与输入相关的istream类成员函数简介

    eof 函数 eof是end of file的缩写,表示"文件结束".从输入流读取数据,如果到达文件末尾(遇文件结束符),eof函数值为非零值(真),否则为0(假). [例] 逐个读入一行字符,将其中的非空格字符输出. #include <iostream> using namespace std; int main( ) { char c; while(!cin.eof( )) //eof( )为假表示未遇到文件结束符 if((c=cin.get( ))!=' ') //

随机推荐