Filter function in C++

I'm trying to filter some data via boolean functions. Here is my quickly written code, which has errors:

#include <iostream>
#include <cstring>
#include <vector>
using namespace std;
class Person
{
private:
string name;
int age;
double height;
char gender;
public:
Person(string name,int age,double height,char gender);
string getName() {return name};
int getAge() { return age; }
double getHeight() { return height; }
char getGender() { return gender; }
}
Person::Person(string name,int age, double height,char gender)
{
this->name = name;
this->age = age;
this->height = height;
this->gender = gender;
}
bool IsName(Person p, string name)
{
if(p.getName == name) return true;
return false;
}
int IsAge(Person p, int age)
{
if(p.getAge == age) return true;
return false;
}
double IsHeight(Person p, double height)
{
if(p.getHeight == height) return true;
return false;
}
bool IsGender(Person p, char gender)
{
if(p.getGender == gender) return true;
return false;
}
class Group
{
public:
vector <Person> People;
int getPersonCount(bool (*filter)(int));
}
template <class T>
int Group::getPersonCount(bool (*filter)(T), T t)
{
int ct = 0;
for(int i=0;i<People.size();i++) if(People[i],filter(t)) ct++;
return ct;
}
int main()
{
Person p1("Alice",24,1.80,'F'), p2("Bob",18,1.60,'M'), p3("Charlie",30,1.70,'M');
Group g;
g.People.push_back(p1);
g.People.push_back(p2);
g.People.push_back(p3);
cout<<g.getPersonCount(&IsName,"Alice");
return 0;
}

I tried passing the filter function as a parameter using templates. I'd like to know if it's possible to do that in C++. I know it's possible in Lua and I'm just not sure how this could be implemented into C++ code.

Your IsXXX() functions are not calling your Person methods correctly, as you are missing the required () parenthesis on the method calls. Also, the return types on IsAge() and IsHeight() are wrong, they should all be bool.

The functions should look more like this instead:

bool IsName(Person p, string name)
{
return (p.getName() == name);
}
bool IsAge(Person p, int age)
{
return (p.getAge() == age);
}
bool IsHeight(Person p, double height)
{
return (p.getHeight() == height);
}
bool IsGender(Person p, char gender)
{
return (p.getGender() == gender);
}

You really should be passing the Person object as a const Person& reference instead, but that requires you to also quality your Person methods as const (which you should, since they are read-only).

But, that being said, the rest of your code is still not usable, because:

• your Person::getName() method is missing a ; on the return statement.

• you are missing ; on the end of each class declaration.

• Group::getPersonCount() is not declared as a templated function, but you are trying to define it as if it were.

• the arguments in getPersonCount()'s declaration do not match the arguments in its definition.

• your IsXXX() functions do not match the function signature that getPersonCount() is expecting anyway.

Try something more like this instead:

#include <iostream>
#include <vector>
using namespace std;
class Person
{
private:
string name;
int age;
double height;
char gender;
public:
Person(string name, int age, double height, char gender);
string getName() const { return name; };
int getAge() const { return age; }
double getHeight() const { return height; }
char getGender() const { return gender; }
};
Person::Person(string name, int age, double height, char gender)
: name(name), age(age), height(height), gender(gender)
{
}
bool IsName(const Person& p, const string& name)
{
return (p.getName() == name);
}
bool IsAge(const Person& p, int age)
{
return (p.getAge() == age);
}
bool IsHeight(const Person& p, double height)
{
return (p.getHeight() == height);
}
bool IsGender(const Person& p, char gender)
{
return (p.getGender() == gender);
}
class Group
{
public:
vector <Person> People;
template <class T, class U>
int getPersonCount(bool (*filter)(const Person&, T), const U& value)
{
int ct = 0;
for(size_t i = 0; i < People.size(); ++i) {
if (filter(People[i], value))
++ct;
}
return ct;
}
};
int main()
{
Person p1("Alice", 24, 1.80, 'F'), p2("Bob", 18, 1.60, 'M'), p3("Charlie", 30, 1.70, 'M');
Group g;
g.People.push_back(p1);
g.People.push_back(p2);
g.People.push_back(p3);
cout << g.getPersonCount(&IsName, "Alice");
return 0;
}

Online Demo

That being said, you can simplify getPersonCount() a little by using a template for the whole type of the filter argument, rather than just the type of one of its input arguments, eg:

class Group
{
public:
...
template <class Filter, class T>
int getPersonCount(Filter filter, const T& value)
{
int ct = 0;
for(size_t i = 0; i < People.size(); ++i) {
if (filter(People[i], value))
++ct;
}
return ct;
}
};

This then allows you to use any callback object that can be invoked with operator() and accepts a Person and a T as arguments. Not just standalone functions, but also the return value of std::bind(), and lambdas too.

Online Demo

In which case, you may as well simply get rid of your IsXXX() functions altogether and use std::count_if() instead with a lambda as its predicate, eg:

...
#include <algorithm>
...
class Group
{
public:
...
template <class Filter>
int getPersonCount(Filter filter)
{
return count_if(People.begin(), People.end(), filter);
}
};
...
cout << g.getPersonCount( [](const Person &p){ return p.getName() == "Alice"; } );

Online Demo