In C++, how to find certain items in the vector of objects by giving the member of a object?

Question

For example, I have defined the class foo and the vector vec:

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
class foo {
public:
    foo(int flag, char ch):flag(flag), ch(ch) {}
    int flag;
    char ch;
};
int main(void)
{
    vector<foo> vec;
    vec.push_back(foo(1,'a'));
    vec.push_back(foo(2,'b'));
    vec.push_back(foo(3,'c'));
    //blabla...
}

I've found how to find the single element: How to find an item in a std::vector?
But now I want to find an object by just giving a char, say, 'b'. How can I achieve this goal efficiently?

do you know how to iterate over a vector and use the == operator? — David Haim, Jul 13 '15 at 07:51
@DavidHaim I know that, but I feel it's inefficient when the vector becomes too large. So ...^_^ — Harold Huang, Jul 13 '15 at 07:52
@HaroldHuang If you want efficient searches, use a sorted vector and binary search, or don't use a vector. — molbdnilo, Jul 13 '15 at 07:54
@Melebius No... It's just a simple example class... I think I need vector more than map. — Harold Huang, Jul 13 '15 at 07:55
@AshwaniDausodia I don't know how to implement that, so can you show me an example? Just use the code I've given. — Harold Huang, Jul 13 '15 at 07:57
@HaroldHuang I wont be difficult to implement. Follow this link http://www.cplusplus.com/reference/algorithm/find/ — Ashwani, Jul 13 '15 at 07:58

TartanLlama · Accepted Answer · 2015-07-13T08:17:42.517

You could use std::find_if for this:

 //c++14
 std::find_if(std::begin(vec),std::end(vec),
              [](auto&& v) { return v.ch == 'b'; })

 //c++11
 std::find_if(std::begin(vec),std::end(vec),
              [](const foo& v) { return v.ch == 'b'; })

You could wrap this up in a function if you find yourself needing this pattern a number of times:

//c++14, c++11 version left as exercise
decltype(auto) find_foo (const std::vector<foo>& vec, char c)
{
    return std::find_if(std::begin(vec),std::end(vec),
                        [c](auto&& v) { return v.ch == c; });
}

A better option might be to use a std::unordered_map<char,int> instead of a std::vector<foo>:

int main()
{
    std::unordered_map<char,int> my_map;
    my_map['a'] = 1;
    my_map['b'] = 2;
    my_map['c'] = 3;

    cout << my_map['b']; //instead of that std::find_if nonsense
}

Em... Thank you for your answer but my compiler says that the `auto` in your first code block isn't allowed and I don't konw why. I'm using Visul Studio 2012. — Harold Huang, Jul 13 '15 at 08:07

Vlad from Moscow · Answer 2 · 2015-07-13T08:17:21.697

You can use standard algorithm std::find_if declared in header <algorithm>. For example

#include <iostream>
#include <algorithm>

class foo {
public:
    foo(int flag, char ch):flag(flag), ch(ch) {}
    int flag;
    char ch;
};

int main()
{
    std::vector<foo> vec;

    vec.push_back(foo(1,'a'));
    vec.push_back(foo(2,'b'));
    vec.push_back(foo(3,'c'));

    char ch = 'b';
    auto it = std::find_if( vec.begin(), vec.end(), 
                            [&]( const foo &f ) { return f.ch == ch; } );

    if ( it != vec.end() ) std::cout << it->flag << ' ' << it->ch << std::endl;

}

If your compiler supports C++14 then the lambda expression can be written also the following way

auto it = std::find_if( vec.begin(), vec.end(), 
                        [ch = 'b']( const foo &f ) { return f.ch == ch; } );

The other approach is to make the seach as an interface of the class itself. For example

class foo {
public:
    foo(int flag, char ch):flag(flag), ch(ch) {}
    int flag;
    char ch;
    class find_by_ch
    {
    public:        
        find_by_ch( char ch ) : ch( ch ) {}
        bool operator ()( const foo &f ) const { return f.ch == ch; }
    private:
        char ch;
    };        
};

//...

auto it = std::find_if( vec.begin(), vec.end(), foo::find_by_ch( 'b' ) );

@Harold Huang What is not clear? See also my updated post.:) — Vlad from Moscow, Jul 13 '15 at 08:17
Oh, I've make myself clear. Thanks a million! The latter approach is inspiring. — Harold Huang, Jul 13 '15 at 08:25
But it seems that to accept multiple answers isn't allowed, I'm sorry. — Harold Huang, Jul 13 '15 at 08:28

Shreevardhan · Answer 3 · 2015-07-13T08:36:48.103

Define an implicit constructor for foo using only char as argument.

foo(char ch) : ch(ch), flag(int()) {
}

OR add default args to your existing constructor

foo(char ch, int flag = int()) : ch(ch), flag(flag) {
}

AND overload a comparison operator

bool operator ==(const char & rhs) {
    return ch == rhs;
}

You can then use std::find directly.

vector<foo>::iterator it = std::find(vec.begin(), vec.end(), 'b');
if (it != vec.end()) {
    ...    // do something
}

A working code will then look like

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

class foo {
public:
    foo(char ch, int flag = int()) : flag(flag), ch(ch) {}
    int flag;
    char ch;
    inline bool operator ==(const char & rhs) { return ch == rhs; }
};

int main(void) {
    vector<foo> vec;
    vec.push_back(('a', 1));
    vec.push_back(('b', 2));
    vec.push_back(('c', 3));
    vector<foo>::iterator it = find(vec.begin(), vec.end(), 'b');
    if (it != vec.end())
        cout << "found" << endl;
    return 0;
}

See http://ideone.com/ue907i demo.

score 0 · Answer 4 · answered Jul 13 '15 at 08:01

0

If the vector is sorted (as in your example), you can use lower_bound for logarithmic performance. If the vector is not sorted, you can use find for linear performance.

answered Jul 13 '15 at 08:01

fluffybunny

496
3
8

In C++, how to find certain items in the vector of objects by giving the member of a object?

4 Answers4

Linked

Related