C++ How to make find_if not only return the first object for which applying pred to it is true

Question

This is meant to allow user to input name, contact and address he/she wishes to search for. What I wanted to do is to display all objects that applying pred to it is true but I can't seems to get it working.

static string searchName, searchContact, searchAddress;

bool search_User(User &u)
{ 
   return (u.getName() == searchName && u.getContact() == searchContact && u.getAddress() == searchAddress);

}
void searchUser(vector<User> &u)
{
    cout << "Name of user: ";
    getline(cin, searchName);
    cout << "Contact of tutor: ";
    getline(cin, searchContact);
    cout << "Adress of user: ";
    getline(cin, searchAddress);
    vector<User>::iterator i;
    i = find_if(u.begin(), u.end(), search_User);
    cout << i->getName() << i->getContact() << i->getAddress() << endl;
}

Answer 1

The usual solution is to use std::copy_if:

std::vector<User> matches;
std::copy_if(v.begin(), v.end(), std::back_inserter(matches),
    [Name, Contact, Address](User const& u)
    { return u.getName() == Name && u.getContact() == Contact && u.getAddress() == Address;});

or just write a classic loop

for (User& u : users) {
  if (search_User(u) {
    std::cout << u; // Assumes you've implemented operator<<(ostream&, User)
  }
} 

Answer 2

Pseudocode:

for(iterator i = v.begin(); 
    (i = find_if(i, v.end(), ...)) != v.end(); ++i )
{
    print *i;
}

Answer 3

One method would be to use std::copy_if (since C++11) or std::remove_copy_if by negating your predicate with not1 – this copy_if workaround I found in the answer to "Why there is no std::copy_if algorithm?".

std::vector<User> result;
std::remove_copy_if(u.begin(), u.end(),
                    std::back_inserter(result),
                    std::not1(std::ptr_fun(search_User)));

Another method would be to use the std::partition algorithm.

Reorders the elements in the range [first, last) in such a way that all elements for which the predicate p returns true precede the elements for which predicate p returns false.
_{(http://en.cppreference.com/w/cpp/algorithm/partition)}

std::vector<User>::const_iterator newend =
    std::partition(u.begin(), u.end(), search_User);

Answer 4

(Requires C++11) A slight variation on that proposed by MSalters would be to write to std::cout as matches are found:

#include <iostream> 
#include <vector>
#include <string>
#include <algorithm>
#include <iterator>

...

std::ostream& operator<<(std::ostream& a_out, const User& a_user)
{
    std::cout << a_user.getName() << ", " << a_user.getContact() << ", " <<
        a_user.getAddress();
    return a_out;
}

...

std::copy_if(users.begin(),
             users.end(),
             std::ostream_iterator<const User>(std::cout, "\n"),
             [name, contact, address](const User& a_user)
             {
                return name    == a_user.getName()    &&
                       contact == a_user.getContact() &&
                       address == a_user.getAddress();
             });

EDIT:

To display a "User not found" message you could modify it as follows:

int count = 0;
std::copy_if(users.begin(),
             users.end(),
             std::ostream_iterator<const User>(std::cout, "\n"),
             [&count, name, contact, address](const User& a_user) -> bool
             {
                if (name    == a_user.getName()    &&
                    contact == a_user.getContact() &&
                    address == a_user.getAddress())
                {
                    count++;
                    return true;
                }
                return false;
             });

if (!count) std::cout << "User not found\n";

Answer 5

For C++14, my preferred solution is to use std::copy_if and return a vector of all matches and pass in parameters required to maintain compartmentalization:

std::vector<User> findMatches( const std::vector<User> &v) {
    std::vector<User> matches;
    std::copy_if(v.begin(), v.end(), std::back_inserter(matches),
    [Name, Contact, Address](User& u)
    { 
         return(u.getName() == Name 
             && u.getContact() == Contact 
             && u.getAddress() == Address);
    });
    return matches;
}

The currently top posted solution by @MSalters has a bug in the lambda which is missing a return statement.

https://godbolt.org/g/CQOXzv

http://cpp.sh/2j7q7

$ g++-5 -std=c++14 user.cpp -o test.bin
$ ./test.bin

To compile in command line, save following as user.cpp, and run:

#include <string>
#include <algorithm>
#include <vector>
#include <iostream>

class User {
    public:
        std::string Name;
        std::string Contact;
        std::string Address;

        auto getName() {
            return Name;
        }
        auto getContact() {
            return Contact;
        }
      auto getAddress() {
          return Address;
      }
      User() = default;
};

std::ostream & operator<<(std::ostream &stream, const User &u)
{
    stream << u.Name << " " << u.Contact << " " << u.Address;
    return stream;
}

std::vector<User> findmatches( std::vector<User> &v, 
                           std::string Name, 
                           std::string Contact, 
                           std::string Address) {
    std::vector<User> matches;
    std::copy_if(v.begin(), v.end(), std::back_inserter(matches),
    [Name, Contact, Address](User& u)
    {
        return(u.getName() == Name 
        && u.getContact() == Contact 
        && u.getAddress() == Address);
    });
    return matches;
}


int main () {

std::vector<User> v {};
v.push_back({"Tom Cruise","917-032-2342","200 Top Gun Lane, Miramar, CA 93212"});
v.push_back({"Chuck Norris","911-032-1111","300 Santa Monica Blvd, Hollywood, CA 93212"});
v.push_back({"Santa Clause","315-4323-3111","1 North Pole Circle, North Pole, Elf Division, Antarctica 00000"});

auto matches = findmatches(v, "Chuck Norris", "911-032-1111", "300 Santa Monica Blvd, Hollywood, CA 93212");

for ( auto i : matches ) {
    std::cout << i << std::endl; 
  }
}

Answer 6

You can loop through all hits by incrementing the return value of find_if() and passing it to a subsequent call, e.g.:

// Switched to const_iterator, purely because the example code wasn't
// changing the elements found.
vector<User>::const_iterator i = find_if(u.begin(), u.end(), search_User);

while (i != u.end())
{
    cout << i->getName() << i->getContact() << i->getAddress() << endl;
    ++i;
    i = find_if(i, u.end(), search_User);
}

Answer 7

To convert static vars to struct:

struct Search_conditions
{
    string name, contact, address;

    bool operator()(User& u) {...}
};

Search_conditions sc = {name, contact, address};
find_if(u.begin(), u.end(), sc);