C++11 find和find_if的用法

灰太狼 2022-03-18 05:09 361阅读 0赞

回顾学习find和find\_if, 网上查了一下资料，这里记录一下。

STL的find，find\_if函数提供了一种对数组、STL容器进行查找的方法。使用该函数，需 \#include <algorithm>  
我们查找一个list中的数据，通常用find()，例如：

#    1、find #

using namespace std;  
int main()  
\{  
    list<int> lst;  
    lst.push\_back(10);  
    lst.push\_back(20);  
    lst.push\_back(30);  
    list<int>::iterator it = **find(lst.begin(), lst.end(), 10)**; // 查找list中是否有元素“10”  
    if (it != lst.end()) // 找到了  
    \{  
        // do something   
    \}  
    else // 没找到  
    \{  
        // do something  
    \}  
    return 0;  
\}

那么，如果容器里的元素是一个类呢？例如，有list<CPerson> ，其中CPerson类定义如下：  
class CPerson  
\{  
public:  
    CPerson(void);   
    ~CPerson(void);

**bool CPerson::operator==(const CPerson &rhs) const  
    \{  
        return (age == rhs.age);  
    \}**  
public:  
    int age; // 年龄  
\};

那么如何用find()函数进行查找呢？这时，我们需要提供一个判断两个CPerson对象“相等”的定义，find()函数才能从一个list中找到与指定的CPerson“相等”的元素。  
      这个“相等”的定义，是通过重载“==”操作符实现的，我们在CPerson类中添加一个方法，定义为：  
bool operator==(const CPerson &rhs) const;  
      实现为：  
**bool CPerson::operator==(const CPerson &rhs) const  
\{  
    return (age == rhs.age);  
\}**

然后我们就可以这样查找（假设list中已经有了若干CPerson对象）了：

list<CPerson> lst;  
// 向lst中添加元素，此处省略

CPerson cp\_to\_find; // 要查找的对象  
cp\_to\_find.age = 50;  
list<CPerson>::iterator it = **find(list.begin(), list.end(), cp\_to\_find);** // 查找

if (it != lst.end()) // 找到了  
\{  
\}  
else // 没找到  
\{  
\}  
这样就实现了需求。

# 2、find\_if #

有人说，如果我有自己定义的“相等”呢？例如，有一个list<CPerson\*>，这个list中的每一个元素都是一个对象的指针，我们要在这个list中查找具有指定age的元素，找到的话就得到对象的指针。  
      这时候，你不再能像上面的例子那样做，我们需要用到find\_if函数，并自己指定predicate function（即find\_if函数的第三个参数，请查阅STL手册）。先看看find\_if函数的定义：

template<class InputIterator, class Predicate>  
InputIterator find\_if(InputIterator \_First, InputIterator \_Last, Predicate \_Pred);

Parameters  
\_First  
An input iterator addressing the position of the first element in the range to be searched.  
\_Last  
    An input iterator addressing the position one past the final element in the range to be searched.  
\_Pred  
    User-defined predicate function object that defines the condition to be satisfied by the element being searched for. A predicate takes single argument and returns true or false.

我们在CPerson类外部定义这样一个结构体：  
**typedef struct finder\_t  
\{  
    finder\_t(int n) : age(n) \{ \}   
    bool operator()(CPerson \*p)   
    \{   
        return (age == p->age);   
    \}   
    int age;  
\}finder\_t;**

然后就可以利用find\_if函数来查找了：  
list<CPerson\*> lst;  
// 向lst中添加元素，此处省略

list<CPerson\*>::iterator it = **find\_if(lst.begin(), lst.end(), finder\_t(50))**; // 查找年龄为50的人  
if (it != lst.end()) // 找到了  
\{  
    cout << "Found person with age : " << (\*it)->age;  
\}  
else // 没找到  
\{  
    // do something  
\}

## 2.1、例子1 ##

map<int, char\*> mapItems;  
auto it = find\_if(mapItems.begin(), mapItems.end(), \[&\](const pair<int, char\*> &item) \{  
    return item->first == 0/\*期望值\*/;  
\});

## 2.2、例子2 ##

**typedef struct** testStruct  
**\{  
    int a;**

**    int b;  
\}**testStruct**;**

vector<testStruct> testStructVector;  
auto itrFind = find\_if(testStructVector.begin(), testStructVector.end(), \[\](testStruct myStruct)  
\{  
     return myStruct.a > 2 && myStruct.b < 8;  
\});  
   
if(itrFind != testStructVector.end())  
        TRACE("found!");  
else  
        TRACE("not found!");

## 2.3、例子3 ##

\#include <string>  
\#include <algorithm>  
class map\_value\_finder  
\{  
public:  
    map\_value\_finder(const std::string &cmp\_string):m\_s\_cmp\_string(cmp\_string)\{\}  
    bool operator ()(const std::map<int, std::string>::value\_type &pair)  
    \{  
        return pair.second == m\_s\_cmp\_string;  
    \}  
private:  
    const std::string &m\_s\_cmp\_string;                      
\};  
   
int main()  
\{  
    std::map<int, std::string> my\_map;  
    my\_map.insert(std::make\_pair(10, "china"));  
    my\_map.insert(std::make\_pair(20, "usa"));  
    my\_map.insert(std::make\_pair(30, "english"));  
    my\_map.insert(std::make\_pair(40, "hongkong"));      
      
    std::map<int, std::string>::iterator it = my\_map.end();  
    it = std::find\_if(my\_map.begin(), my\_map.end(), map\_value\_finder("English"));  
    if (it == my\_map.end())  
       printf("not found\\n");         
    else  
       printf("found key:%d value:%s\\n", it->first, it->second.c\_str());  
         
    return 0;          
\}

## 2.4、例子4 ##

struct map\_value\_finder    
\{    
public:    
    map\_value\_finder(const std::string &cmp\_string):m\_s\_cmp\_string(cmp\_string)\{\}    
    bool operator ()(const std::map<int, std::string>::value\_type &pair)    
    \{    
        return pair.second == m\_s\_cmp\_string;    
    \}    
private:    
    const std::string &m\_s\_cmp\_string;                        
\};

bool funddd(const std::map<int, std::string>::value\_type &pair)    
\{    
    return pair.second == "english";    
\}   
    
int main()    
\{    
    std::map<int, std::string> my\_map;    
    my\_map.insert(std::make\_pair(10, "china"));    
    my\_map.insert(std::make\_pair(20, "usa"));    
    my\_map.insert(std::make\_pair(30, "english"));    
    my\_map.insert(std::make\_pair(40, "hongkong"));        
        
    std::map<int, std::string>::iterator it = my\_map.end();    
    it = std::find\_if(my\_map.begin(), my\_map.end(), funddd);    
    if (it == my\_map.end())    
       printf("not found\\n");           
    else    
       printf("found key:%d value:%s\\n", it->first, it->second.c\_str());

getchar();    
    return 0;            
\}

# 下面再说绑定器bind： #

STL中的绑定器有类绑定器和函数绑定器两种，类绑定器有binder1st和binder2nd，而函数绑定器是bind1st和bind2nd，他们的基本目的都是用于构造一个一元的函数对象。比如这里我们可以利用bind2nd通过绑定二元函数对象中的第二个参数的方式来实现二元谓词向一元谓词的转换。

struct **compare**: binary\_function<A, string,bool> \{  
    bool operator()( A &value, string str) const  
    \{  
        if (value.GetStr()== str)  
            return true;  
        else  
            return false;  
    \}  
\};

示例：  
vector<A>::iterator t=find\_if(a.begin(),a.end(),**bind2nd(compare(), ”33″)**);

无论是用vector的循环还是find\_if泛型算法，在性能和代码复杂度上面都有一定得权衡，至于在实际应用中，还是需要具体问题具体分析的。

## 以下泛型模板 ##

现在还是迷糊的，下面是自己在项目中看到的师傅写的一个比较实用的方法：

template<typename T> bool compare\_no(const T\* s1 , const T\* s2)  
\{    
    return strcmp(s1->no, s2->no) == 0;  
\}

template<typename T> bool less\_no(const T\* s1 , const T\* s2)  
\{  
    return strcmp(s1->no, s2->no) < 0;  
\}

template<typename T> bool compare\_id(const T\* s1 , const T\* s2)  
\{  
    return s1->id == s2->id;  
\}

template<typename T> bool less\_id(const T\* s1 , const T\* s2)  
\{  
    return s1->id < s2->id;  
\}

//排序  
std::sort(vct\_device.begin(), vct\_device.end(), less\_id<ST\_DEVICE>);  
std::sort(vct\_camer.begin(), vct\_camer.end(), less\_no<ST\_CAMERA>);

//通过编号查找ID

vector<ST\_CAMERA\*>::iterator it\_cam;  
ST\_CAMERA tmp\_cam;  
strcpy(tmp\_cam.no, "888888");  
it\_cam = std::find\_if(vct\_camer.begin(),vct\_camer.end(),bind2nd(ptr\_fun(compare\_no<ST\_CAMERA>), &tmp\_cam));  
if (it\_cam != vct\_camer.end())  
     返回值channel = (\*it\_cam)->channel;

//通过ID查找编号

vector<ST\_CAMERA\*>::iterator it\_cam;  
ST\_CAMERA tmp\_cam;  
int camid = 0;  
tmp\_cam.id = 3;  
it\_cam = std::find\_if(vct\_camer\_secd.begin(), vct\_camer\_secd.end(), bind2nd(ptr\_fun(compare\_id<ST\_CAMERA>), &tmp\_cam));  
if (it\_cam == vct\_camer\_secd.end())  
       返回值strcpy(camera,(\*it\_cam)->no);

[https://blog.csdn.net/bobodem/article/details/49386131][https_blog.csdn.net_bobodem_article_details_49386131]

[https_blog.csdn.net_bobodem_article_details_49386131]: https://blog.csdn.net/bobodem/article/details/49386131