C++STL之非变异算法

最新推荐文章于 2019-12-18 17:10:21 发布
最新推荐文章于 2019-12-18 17:10:21 发布
阅读量896 收藏 3
点赞数
分类专栏： 【STL泛型编程】 文章标签： 迭代器 iterator stl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014634338/article/details/38095803
版权



1.循环


1.1主要函数

①for_each

原形: template<classInIt,class Fun>  Funfor_each(InItfirst,InItlast, Fun f);

打印向量中每个整型元素的立方

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
void print(int n)
{
    cout<<n*n*n<<" ";
}
int main()
{
    vector<int>Number(8);
    vector<int>::iterator it=Number.begin();
    for(int i=0;i<8;i++)
    {
        Number[i]=i+1;
    }
    while(it !=Number.end())
    {
        cout<<*it<<" ";
        it++;
    }
    cout<<endl;
    for_each(it=Number.begin(), Number.end(), print);
    cout<<endl;
    return 0;
}

(1)for_each函数各参数的含义。start,end表示向量的起始迭代指针、结束迭代指针，不是具体的值，比如for_each(start[0],end,PrintCube)是错误的，因为start[0]表示的是向量中第一个元素的值1。但for_each(&start[0],end,PrintCube)是正确的,因为&start[0]表示的是第一个元素的地址。

(2)PrintCube函数有且必须只有一个参数，且参数类型与向量的模板类型必须一致。

PrintCube)是错误的，因为start[0]表示的是向量中第一个元素的值1。但for_each(&start[0],end, PrintCube)是正确的,因

为&start[0]表示的是第一个元素的地址。

(2)PrintCube函数有且必须只有一个参数，且参数类型与向量的模板类型必须一致。



求整数向量的和、最大值、最小值

分析：由于必须遍历整形向量的每个元素，因此可以应用for_each函数。当然可以应用全局函数的方法完成所需功能，但更好的方法 是定义一个类。 

#include <iostream>
#include <algorithm>
using namespace std;
class print
{
private:
    int sum;
    int Max;
    int Min;
    int count;
public:
    print():count(0),sum(0){}
    int GetSum()
    {
        return sum;
    }
    int GetMax()
    {
        return Max;
    }
    int GetMin()
    {
        return Min;
    }
    void operator()(int x)
    {
        if(count==0)
        {
            Max=x;
            Min=x;
        }
        else
        {
            if(Max<x)
            {
                Max=x;
            }
            if(Min>x)
            {
                Min=x;
            }
        }
        sum+=x;
        count++;
    }
};
int main()
{
    int a[]={1,4,2,8,5,7};
    const int N=sizeof(a)/sizeof(int);
    print p=for_each(a,a+N,print());
    cout<<p.GetSum()<<endl;
    cout<<p.GetMax()<<endl;
    cout<<p.GetMin()<<endl;
    return 0;
}



2.查询

主要函数

①find

原形：template<class InIt,class T>    InItfind(InItfirst,InItlast,constT&val);

该函数是查询[first,last)间迭代器对应的元素值是否有等于val的，若有则返回其迭代器指针，若无则返回last。可知查询元素的范围是N：[0，last-first), 由于


要判定*(first+N)==val,因此模板T对应的类必须重载运算符“operator==”。


②find_if

原型：template<classInIt,classPred> InItfind_if(InItfirst,InItlast,Predpr);

参数说明:


该函数是查询[first,last)间迭代器对应的元素*(first+i)，若pr(*(first+i))返回true，则返回此时的迭代器指针，表明满足条件的元素已找到；若没有找到则返回


last。


③find_first_of

原型：

template<class FwdIt1, classFwdIt2>FwdIt1find_first_of(FwdIt1first1, FwdIt1 last1,FwdIt2 first2, FwdIt2 last2); 


template<classFwdIt1, class FwdIt2, classPred>FwdIt1find_first_of(FwdIt1first1, FwdIt1 last1,FwdIt2 first2, FwdIt2 last2,Pred pr)


第1个原型含义是：若第一个前向迭代器FwdIt1---[first1,last1)间第N个元素与第二个前向迭代器FwdIt2---[first2,last2)间某元素相等，且N最小，则返回


first1+N。表明第一个前向迭代器FwdIt1中有元素与第二个前向迭代器FwdIt2中的元素相等，否则返回last1。第2个原型与第1个类似,只不过要定义预判定函


数pr(*(first1+N),*(first2+M))。


④adjacent_find

 原型: template<classFwdIt> FwdItadjacent_find(FwdItfirst,FwdItlast);


            template<class FwdIt,class Pred>FwdItadjacent_find(FwdItfirst,FwdItlast,Predpr);


第1个原型含义是:若前向迭代器FwdIt中存在第N个元素，有*(first+N)=*(first+N+1),且N最小，则表明有两个相邻元素是相等的，返回(first+N),否则返回


last。第2个原型与第1个类似,只不过要定义预判定函数pr(*(first+N),*(first+N+1))。

⑤find_end

原型:template<class FwdIt1, class FwdIt2> FwdIt1find_end(FwdIt1first1, FwdIt1 last1,FwdIt2 first2, FwdIt2 last2);


template<class FwdIt1, class FwdIt2,class Pred>   FwdIt1find_end(FwdIt1first1, FwdIt1 last1,FwdIt2 first2, FwdIt2 last2, Predpr);


第1个原型含义是:若前向迭代器FwdIt1从第N个元素开始:*（first1+N）=*(first2+0)，*（first1+N+1）=*(first2+1),*[first1+(last2-first2-1)]= *[first2+(last2-first2-


1)],且N最大，则返回（first1+N）,否则返回last1。也即是：返回在FwdIt1元素中最后一次完全与FwdIt2序列元素匹配的开始位置。第2个原型与第1个类似,


只不过要定义预判定函数pr(*(first1+N+M),*(first2+N+M))。


⑥search

原型： 

template<class FwdIt1, classFwdIt2> FwdIt1search(FwdIt1 first1, FwdIt1 last1,FwdIt2  first2, FwdIt2  last2);

 

template<class FwdIt1, class FwdIt2,class Pred> FwdIt1search(FwdIt1  first1, FwdIt1  last1,FwdIt2 first2, FwdIt  last2,Predpr);


第1个原型含义是:若前向迭代器FwdIt1从第N个元素开始：*（first1+N）=*(first2+0)，*（first1+N+1）=*(first2+1),…,*


[first1+(last2-first2-1)]= *[first2+(last2-first2-1)], 且N最小，则返回（first1+N）,否则返回last2。也即是：返回


在FwdIt1元素中首次完全与FwdIt2序列元素匹配的开始位置。


第2个原型与第1个类似,只不过要定义预判定函数pr(*(first1+N+M),*(first2+M))。


⑦search_n

原型:template<class FwdIt,class Dist,class T>FwdItsearch_n(FwdItfirst,FwdItlast,Distn,constT&val); 


template<classFwdIt,classDist,class T, classPred>FwdItsearch_n(FwdItfirst,FwdItlast,Distn,constT&val,Predpr);


第1个原型含义是：在前向迭代器FwdIt中，从第N个元素开始连续的n个元素满足：*(first+N)=val,*(first+1)=val，...，*(first+N+n)= val,且N最小，则返回


*(first+N),否则返回last。   


第2个原型与第1个类似,只不过要定义预判定函数pr(*(first1+N+M),val))。


7个查询函数简单应用

#include <algorithm>
#include <iostream>
using namespace std;
bool Greater(int m)
{
    return m>4;
}
int main()
{
    int a[]={1,2,2,2,3,4,4,5,6,7,1,2,2,3};
    int Size=sizeof(a)/sizeof(int);
    cout<<"原始数组:"<<endl;
    copy(a, a+Size,ostream_iterator<int>(cout,"\t"));
    cout<<endl;
    int *p1=find(a,a+Size,3);
    if(p1!=a+Size)
    {
        cout<<"find首次等于3的位置:"<<p1-a<<"\t值:"<<*p1<<endl;
    }
    cout<<endl;
    int *p2=find_if(a,a+Size,Greater);
    if(p1!=a+Size)
    {
        cout<<"find_if首次大于4的位置:"<<p2-a<<"\t值:"<<*p2<<endl;
    }
    cout<<endl;
    int b[]={10,12,6};
    int Size2=sizeof(a)/sizeof(int);
    int *p3=find_first_of(a,a+Size,b,b+Size2);
    if(p3!=a+Size)
    {
        cout<<"find_first_of首次在a数组中发现b数组中元素的位置:"<<p3-a<<"\t值:"<<*p3<<endl;
    }
    cout<<endl;
    int *p4=adjacent_find(a,a+Size);
    if(p4!=a+Size)
    {
        cout<<"adjacent_find首次相邻元素相同位置:"<<p4-a<<"\t值:"<<*p4<<endl;
    }
    cout<<endl;
    int c[]={2,3};
    int Size3=sizeof(c)/sizeof(int);
    int *p5=find_end(a,a+Size,c,c+Size3);
    if(p5!=a+Size)
    {
        cout<<"find_end最后一次匹配c数组中元素的位置:"<<p5-a<<"\t值:"<<*p5<<endl;
    }
    cout<<endl;
    int *p6=search(a,a+Size,c,c+Size3);
    if(p6 != a+Size)
    {
        cout<<"search首次匹配c数组中元素的位置:"<<p6-a<<"\t值:"<<*p5<<endl;
    }
    int *p7=search_n(a,a+Size,3,2);
    if(p7!=a+Size)
    {
        cout<<"首次出现3个2的位置:"<<p7-a<<"\t值:"<<*p7<<endl;
    }
    cout<<endl;
    return 0;
}

根据学号查询学生信息，且已知学号是关键字。 

#include <algorithm>
#include <iostream>
#include <vector>
#include <string>
using namespace std;
class Student
{
public:
    int NO;
    string name;
    Student(int N,string nam):NO(N),name(nam){}
    bool operator == (int NO)
    {
        return this->NO==NO;
    }
};
int main()
{
    vector<Student>v;
    Student s1(101,"张三");
    Student s2(102,"张四");
    v.push_back(s1);
    v.push_back(s2);
    
    vector<Student>::iterator begin,end,it_find;
    begin=v.begin();
    end=v.end();
    
    int FindNO=102;
    it_find=find(begin,end,FindNO);
    if(it_find!=end)
    {
        cout<<(*it_find).NO<<"\t"<<(*it_find).name<<endl;
    }
    return 0;
    
}
已知学生基本属性：学号（整形，关键字），姓名，成绩。现在要求编相关的功能类，能添加学生对象，并具有下列查询功能：（1）按学号查询；（2）按一组学号查询；（3）按姓名查询；（4）按成绩查询；（5）按成绩范围查询。并编制简单的测试类加以测试。

分析:

  (1)设计思想：采取基本类、集合类设计方法，在集合类中进行添加、查询功能。

  (2)实现查询功能用哪个具体查询函数呢？对于按学号查询，由于学号是关键字，因此用find函数即可；对于按一组学号查询，最好用find_first_of函数，但该函数一次只能查到一个学号的学生信息，因此一定要采用循环结构，才能完成一组学号的查询；对于按姓名查询，采用find函数。由于姓名不是关键字，因此也应该采用循环结构；对于按成绩查询，应该用find函数，由于成绩不是关键字，因此也应该采用循环结构；按成绩范围查询，应采用find_if函数，当然也是循环结构。


#include <algorithm>
#include <iostream>
#include <vector>
#include <string>
using namespace  std;
const int NO_FIND=1;
const int GRADE_FIND=2;
class Student
{
public:
    int NO;
    string name;
    int grade;
    static int mark;
    Student(int Number,string Name,int Grade):NO(Number),name(Name),grade(Grade){}
    bool operator==(const int n)const
    {
        if(mark==NO_FIND)
        {
            return NO==n;
        }
        else
        {
            return grade==n;
        }
    }
    bool operator==(const string Name)const
    {
        return name.compare(Name)==0;
    }
};
int Student::mark=-1;
ostream &operator<<(ostream &os,const Student &s)
{
    os<<s.NO<<"\t"<<s.name<<"\t"<<s.grade<<endl;
    return os;
}
class StudentFindIF
{
private:
    int low;
    int hight;
public:
    StudentFindIF(int L,int H):low(L),hight(H){}
    bool operator()(Student &s)
    {
        return s.grade>=low&&s.grade<=hight;
    }
};
class StudentCollect
{
    vector<Student>VecStud;
public:
    bool Add(Student &s)
    {
        VecStud.push_back(s);
        return true;
    }
    bool FindByNO(int no)
    {
        Student::mark=NO_FIND;
        vector<Student>::iterator te=find(VecStud.begin(),VecStud.end(),no);
        if(te!=VecStud.end())
        {
            cout<<*te<<endl;
        }
        else
        {
            cout<<"没有"<<endl;
        }
        return true;
    }
    bool FindByNO(int no[],int n)
    {
        bool bFind=false;
        Student::mark=NO_FIND;
        vector<Student>::iterator te=find_first_of(VecStud.begin(),VecStud.end(),no,no+n);
        while(te!=VecStud.end())
        {
            bFind=true;
            cout<<*te<<endl;
            te++;
            te=find_first_of(te,VecStud.end(),no,no+n);
        }
        if(!bFind)
        {
            cout<<"没有"<<endl;
        }
        return true;
    }
    bool FindByName(string Name)
    {
        bool bFind=false;
        vector<Student>::iterator te=find(VecStud.begin(),VecStud.end(),Name);
        while(te!=VecStud.end())
        {
            bFind=true;
            cout<<*te<<endl;
            te++;
            te=find(te,VecStud.end(),Name);
        }
        if(!bFind)
        {
            cout<<"没有"<<endl;
        }
        return true;
    }
    bool FindByGrade(int Grade)
    {
        Student::mark=GRADE_FIND;
        bool bFind=false;
        vector<Student>::iterator te=find(VecStud.begin(),VecStud.end(),Grade);
        while(te!=VecStud.end())
        {
            bFind=true;
            cout<<*te<<endl;
            te++;
            te=find(te,VecStud.end(),Grade);
        }
        if(!bFind)
        {
            cout<<"没有"<<endl;
        }
        return true;
    }
    bool FindByRange(int low,int hight)
    {
        bool  bFind=false;
        StudentFindIF sf(low,hight);
        vector<Student>::iterator te=find_if(VecStud.begin(),VecStud.end(),sf);
        while (te!=VecStud.end())
        {
            bFind=true;
            cout<<*te<<endl;
            te++;
            te=find_if(te,VecStud.end(),sf);
        }
        return true;
    }
};
int main()
{
    Student s1(101,"张三",50);
    Student s2(102,"李四",70);
    Student s3(103,"张三",60);
    Student s4(104,"王五",50);
    Student s5(105,"王五",80);
    StudentCollect manage;
    manage.Add(s1);
    manage.Add(s2);
    manage.Add(s3);
    manage.Add(s4);
    manage.Add(s5);
    cout<<"按学号查询（102）:"<<endl;
    manage.FindByNO(102);
    cout<<"按姓名查询（张三）:"<<endl;
    manage.FindByName("张三");
    cout<<"按成绩查询:"<<endl;
    manage.FindByGrade(50);
    
    int a[]={101,105,103,107};
    cout<<"按学号组查询:"<<endl;
    manage.FindByNO(a,sizeof(a)/sizeof(int));
    cout<<"按成绩范围查询[55,70]:"<<endl;
    manage.FindByRange(55,70);
    return 0;
    
}

3.计数

主要函数

①count原型：template<class InIt,class T> size_tcount(InItfirst, InItlast,const T& val);

该函数返回[first, last)间的元素数目，这些元素满足*(first+i) = val;


②count_if

原型：template<class InIt,class Pred,class Dist> size_t count_if(InIt first, InIt last,Pred pr);

该函数是查询[first, last)间迭代器对应元素*(first+i)的总数，条件是pr(*(first+i))返回值是true。


3.1.求数组中有多少个0


<span style="font-size:14px;">#include <algorithm>
#include <iostream>
using namespace std;
int main()
{
    int a[]={2,0,4,6,0,3,1,-7};
    const int N=sizeof(a)/sizeof(int);
    cout<<count(a,a+N,0)<<endl;
    return 0;
}</span>

3.2 查询有多少个学生成绩为 80 分 

#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
class Student
{
public:
    int NO;
    string name;
    int grade;
    Student(int NO,string Name,int G):NO(NO),name(Name),grade(G){}
    bool operator==(int Grade)
    {
        return grade==Grade;
    }
};
int main()
{
    vector<Student>v;
    Student s1(1000,"张三",80);
    Student s2(1001,"阿阿",85);
    Student s3(1002,"爱国",80);
    Student s4(1003,"艾丝凡",80);
    v.push_back(s1);
    v.push_back(s2);
    v.push_back(s3);
    v.push_back(s4);
    cout<<"成绩为80分得人数为:"<<count(v.begin(),v.end(),80)<<endl;
    return 0;
}



3.3查询有多少个学生成绩高于80分

#include <algorithm>
#include <functional>
#include <iostream>
#include <vector>
using namespace  std;
class Student
{
public:
    int NO;
    string name;
    int grade;
    Student(int NO,string name,int Grade):NO(NO),name(name),grade(Grade){}
    Student(int Grade):grade(Grade){}
    bool operator==(int Grade)
    {
        return grade=Grade;
    }
    bool operator()(const Student &s)const
    {
        return grade<s.grade;
    }
    void print()
    {
        cout<<NO<<"\t"<<name<<"\t"<<grade<<endl;
    }
};
class MatchExpress
{
    int grade;
public:
    MatchExpress(int Grade):grade(Grade){}
    bool operator()(const Student &s)const
    {
        return s.grade>grade;
    }
};
ostream &operator<<(ostream  &os,const Student &s)
{
    os<<s.NO<<"\t"<<s.name<<"\t"<<s.grade<<endl;
    return os;
}
void print(Student &s)
{
    cout<<s.NO<<"\t"<<s.name<<"\t"<<s.grade<<endl;
}
int main()
{
    vector<Student>v;
    Student s1(1000,"张三",80);
    Student s2(1001,"阿阿",85);
    Student s3(1002,"爱国",80);
    Student s4(1003,"艾丝凡",80);
    v.push_back(s1);
    v.push_back(s2);
    v.push_back(s3);
    v.push_back(s4);
    
    copy(v.begin(),v.end(),ostream_iterator<Student>(cout,"\n"));
    cout<<endl;
    for_each(v.begin(),v.end(),print);
    cout<<"成绩高于80的人数为:"<<count_if(v.begin(),v.end(),MatchExpress(80))<<endl;
    cout<<"成绩高于80的人数为:"<<count_if(v.begin(),v.end(),Student(80))<<endl;
    
    return 0;
}


4.比较

①equal原型： 

template<class InIt1, classInIt2>boolequal(InIt1 first, InIt1 last, InIt2 x);


template<class InIt1, classInIt2, class Pred>boolequal(InIt1 first, InIt1 last, InIt2 x, Predpr);


第1个原型含义是：对两个输入迭代器而言，若依次有：*(first+0)=*(x+0), *(first+1)=*(x+1),…*[first+(last-first-1)] =*[x+(last-first-1)],那么这两个容器序列是


相等的。


第2个原型与第1个类似, 只不过要定义预判定函数pr(*(first1+N),*(first2+N))。


②mismatch原型：


template<class InIt1, classInIt2>pair<InIt1, InIt2>mismatch(InIt1 first, InIt1 last, InIt2 x);


template<class InIt1,class InIt2,class Pred>pair<InIt1,InIt2>mismatch(InIt1 first,InIt1 last,InIt2 x, Predpr);


第1个原型含义是：对两个迭代器而言，返回第1对元素不相等时的迭代器指针，保存在pair对象中。pair有两个成员变量：first,second，分别表示Init1及


Init2不相等时的迭代指针。


第2个原型与第1个类似, 只不过要定义预判定函数pr(*(first1+N),*(first2+M))。


4.1 比较两个整型数组是否相等


<span style="font-family:SimSun;font-size:14px;">#include <algorithm>
#include <iostream>
using namespace std;
int main()
{
    int a1[]={3,1,4,1,5,9,2};
    int a2[]={3,1,4,1,5,9,3};
    const int N=sizeof(a1)/sizeof(int);
    cout<<equal(a1,a1+N,a2)<<endl;
    return 0;
}</span>


4.2寻找两个整型数组元素不相等的元素值


#include <algorithm>
#include <iostream>
using namespace std;
int main()
{
    int a1[]={3,1,4,1,5,9,2};
    int a2[]={3,1,4,1,5,9,3};
    const int N=sizeof(a1)/sizeof(int);
    pair<int*, int*>result=mismatch(a1,a1+N,a2);
    cout<<*(result.first)<<"\t"<<*(result.second)<<endl;
    return 0;
}


4.3查询第一对成绩不相等学生的信息



#include <algorithm>
#include <iostream>
#include <vector>
#include <string>
using namespace std;
class Student
{
public:
    int NO;
    string name;
    int grade;
    Student(int NO,string name,int grade):NO(NO),name(name),grade(grade){}
    bool operator==(const Student &s)const
    {
        return this->grade==s.grade;
    }
};
int main()
{
    vector<Student>v1;
    Student s1(101,"aaa",50);
    Student s2(102,"bbb",70);
    Student s3(103,"ccc",60);
    
    v1.push_back(s1);
    v1.push_back(s2);
    v1.push_back(s3);
    vector<Student>v2;
    
    Student s4(104,"ddd",50);
    Student s5(105,"eee",80);
    Student s6(106,"fff",60);
    v2.push_back(s4);
    v2.push_back(s5);
    v2.push_back(s6);
    pair<Student*, Student*> result=mismatch(v1.begin(),v1.end(),v2.begin());   //这里行不通 ？
    Student &stu1=*result.first;
    Student &stu2=*result.second;
    cout<<stu1.NO<<"\t"<<stu1.name<<"\t"<<stu1.grade<<endl;
    cout<<stu2.NO<<"\t"<<stu2.name<<"\t"<<stu2.grade<<endl;
    return 0;
}



STL学习(17)：非变异算法
QQ2558030393的博客
06-24 297
循环 查询 计数 比较 非变异算法主要包含以下函数 序号 功能 函数名称 说明 1 循环 for_each 遍历容器元素，对每元素执行相同的操作 2 查询 find ...
C++STL——各种非变异算法的技术总结和用法代码示例
09-15
经过3天努力，在容器学完后又解决了非变异算法的战斗，感觉收获挺多，拿出来与大家分享，记下来还有变异算法、排序算法和数值算法的总结都会相继分享！
stl-非变异算法
yichudu
10-20 1242
find:在单迭代器序列中找出某zhidiyicichuxiandeweizhi
8.非变异算法
xiaodeguang的博客
03-20 570
1、for_each #include #include #include using namespace std; class Print { private: int sum; int max; int min; int count; public: Print() :count(0), sum(0) {} int GetSum() { return sum; } int
非变异算法
EncodedStar的博客
12-13 577
for_each算法的使用 掌握查询算法find 求所有学生某门课程成绩的和和平均值，以vector为容器，利用函数对象和for_each算法实现。 查找学生成绩为80的学生信息，以vector为容器要求显示格式为“姓名：张三； 学号：001；成绩：80；”。 ， #include <iostream> #include <vector> #include <string> #include <al
C++STL实验报告-迭代器和非变异算法
12-30
在本篇"C++ STL实验报告-迭代器和非变异算法"中，我们将深入探讨C++标准模板库（STL）中的几个核心概念，包括容器、迭代器和非变异算法。实验的目标是熟悉set、multiset、map和multimap这四种关联容器的使用，以及...
C++STL非变异算法技术总结与实例代码解析
标题中的"C++STL——各种非变异算法的技术总结和用法代码示例"意味着本文将集中讲解C++标准模板库（STL）中非变异算法的相关知识点。首先需要明确什么是非变异算法，简单来说，非变异算法是指那些在序列上进行操作，...
C++ STL 非变异算法详解：find与find_if
"C++STL算法技术" C++标准模板库(STL)是C++编程中不可或缺的一部分，其中包含了各种高效、便捷的算法，能够帮助程序员处理数据序列和容器。非变异算法是STL中的一类重要算法，它们不会改变原始数据的顺序或内容，...
C++ STL 变异算法
最新发布
12-26
C++ Standard Template Library (STL) 提供了一系列变异算法，也称为迭代器算法，它们是一组通用的、高性能的函数模板，用于操作容器的元素。这些算法包括排序（sort）、查找（find）、搜索范围（binary_search）、...
【STL】非变异算法之查询
蜕变的博客
08-16 296
本博文主要讲了find 、find_if、find_first_of、find_end、adjacent_find、search、search_n 这些stl中的查询算法 实例1 #include <iostream> #include <algorithm> #include <functional> using namespace std; bool myless(int n) { r
c++STL学习——各种变异算法技术总结和用法代码实例(1)
10-16
变异算法总结了标准库提供的对各种容器操作的变异算法，比如交换、查找、匹配、复制、删除等等。
STL中的常用算法
Vast_Sea的专栏
11-06 3781
From: http://www.cnblogs.com/BeyondAnyTime/archive/2012/05/27/2520532.html 一、非变异算法 是一组不破坏操作数据的模板函数，用来对序列数据进行逐个处理、元素查找、子序列搜索、统计和匹配。非变异算法具有极为广泛的适用性，基本上可应用与各种容器。 1查找容器元素find 它用于查找等于某值的元素。它在迭代器区
【STL】非变异算法之比较
蜕变的博客
08-16 390
本博文主要讲解equal 和 mismatch的使用方法 实例1 /* *【1】equal 判断两个数组是否是相等的 *【2】mismatch 找到两个数组第一队不相等的数*/ #include <iostream> #include <algorithm> #include <vector> using namespace std; int main() { int a[] = {3,
STL之非修改性序列算法1
Android移动开发者
08-11 840
非修改性序列算法是不用使用循环就可以从序列中中找出某些东西的工具。 可分为： for_each算法 元素计数算法 最小值和最大值算法 搜寻算法 区间比较算法 for_each()算法 函数原型: for_each(Iterator begin ,Iterator end ,proc op)算法主要对[begin,end]区间的每个元素调用op。 其中,op可
【STL】非变异算法之计数
蜕变的博客
08-16 299
本博文主要讲解了count count_if 的使用 实例 #include <iostream> #include <algorithm> using namespace std; int main() { int a[] = {1,2,3,4,5,6,6,7,8,9}; int len = sizeof(a)/sizeof(int); cout<<"请输入你想查询的数："
非变异算法之计数(count, count_if)
格物致知
04-26 693
主要函数count, count_if.            template size_t count(InIt first, InIt last, const T& val); template size_t count_if(InIt first, InIt last, Pred pr);统计数组中某个元素出现的次数及大于4的元素个数#include #include #include #include using namespace std; bool matchE
C++中STL的各类算法使用及实现总结
qq_39087999的博客
12-18 570
算法部分主要由头文件<algorithm>，<numeric>和<functional>组成。 <algorithm>是所有STL头文件中最大的一个（尽管它很好理解），它是由一大堆模版函数组成的，可以认为每个函数在很大程度上都是独立的，其中常用到的功能范围涉及到比较、交换、查找、遍历操作、复制、修改、移除、反转、排序、合并等等。 <numer...
C++STL之变异算法
小张的专栏
08-05 914
1.复制 主要函数
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值