在std :: vector结构中找到

Question

I have:

struct MyStruct
{
   char* name;
   int* somethingElse;
};

And I need to find in a std::vector<MyStruct*> an element (by using std::find_if ) whose name is "XYZ" ... but ... the Predicate of std::find_if (if I have managed to understand it correctly) is a plain function, and it takes in a MyStruct pointer and I have no idea where I can specify the extra "XYZ" value to be used in the comparison.

So, how can I use std::find_if or this purpose? (Obviously, looking for a nice solution, not a global variable, or just walk through the list, ....)

Thanks, f

Answer 1

You can use a functor for this (hope I didn't get anything wrong, as I typed it in the browser):

class finder
{
     const char* name;
public:
    finder(const char* _name): name(_name) {}

    bool operator()(MyStruct* elem) {return strcmp(elem->name, name) == 0;}
};

finder f("sample");
std::find_if(myvector.begin(), myvector.end(), f);

Answer 2

If you use C++11 and lambda:

 std::vector<MyStruct> mystructus;
 std::find_if(mystructus.begin(), mystructus.end(), 
             [](const MyStruct& ms){ return ms.name == std::string("XYZ"); } );

Answer 3

You have two options, either use functors or lamdas.

Using functors, you create a new class (or structure) whose constructor takes the string you want to search for, then it has an operator() function that is called by std::find_if :

class my_finder
{
    std::string search;

public:
    my_finder(const std::string& str)
        : search(str)
    {}

    bool operator()(const MyStruct* my_struct) const
        { return search == my_struct->name; }
};

// ...

std::find_if(std::begin(...), std::end(...), my_finder("XYZ"));

The second using lambdas is less code, but requires recent version of the compiler that can handle C++11 lambdas :

std::find_if(std::begin(...), std::end(...), [](const MyStruct* my_struct)
    { return std::string("XYZ") == my_struct->name; });

---

The last example can even be generalized further:

using namespace std::placeholders;  // For `_1` used below in `std::bind`

// Declare a "finder" function, to find your structure
auto finder = [](const MyStruct* my_struct, const std::string& to_find) {
    return to_find == my_struct->name;
};

auto xyz = std::find_if(std::begin(...), std::end(...), std::bind(finder, _1, "XYZ"));
auto abc = std::find_if(std::begin(...), std::end(...), std::bind(finder, _1, "ABC"));

This way the lambda can be reused.

Answer 4

Predicate is anything, that can have operator () applied to it (with the expected argument(s) and returns something convertible to bool). A pointer to function is such thing, but so is an object that defines operator() .

Answer 5

You need to provide a predicate like this:

struct Comparator
{
    Comparator(const char* find) : m_find(find){}
    bool operator()(MyStruct* p) const
    {
        return strcmp(p->name, m_find) == 0;
    }

    const char* m_find;
};

Then you can std::find_if like this:

vector<MyStruct*>::iterator iter = std::find_if(vec.begin(), vec.end(), Comparator("XYZ"));
 if(iter != vec.end())
 {
     MyStruct* p = *iter;
 }

Or if your compiler supports C++11 you can use lambdas and get rid of the predicate functor:

auto it = std::find_if(vec.begin(), vec.end(), [](MyStruct* p) { return strcmp(p->name, "XYZ") == 0;});