Sorting a vector of objects in C++

Question

say I have a class "Information" and it stores the Name and Age of people in a vector.

so...

class Information {

private:
int age;
string name;

//etc, etc...
};

How would I sort the vector in either ascending/descending order with respect to age?

I believe you use something like this.

sort(listOfPeople.begin(), listOfPeople.end(), greater<Information>());

listOfPeople would be the vector.

Any help would be greatly appreciated.

Answer 1

If you want to sort them in non-descending order by age, one way to do it is to define a functor for comparison:

class CompareInformations {
    public:
    // after making CompareInformations a friend class to Information...
    operator(const Information& rhs, const Information& lhs) {
        return rhs.age < lhs.age;
    }
};

And then do your sort:

sort(listOfPeople.begin(), listOfPeople.end(), CompareInformations());

You could also overload operator< for your class, and do without the comparison object:

// inside your class
bool operator <(const Information& rhs) {
    return age < rhs.age;
}

Then sort it:

sort(listOfPeople.begin(), listOfPeople.end());

The above examples assume you want to sort in non-descending (almost ascending, but not quite) order. To do non-ascending order, just change all occurrences of < to >.

Answer 2

You need to create a comparator function or functor class that takes two Information references and returns true if the first should be ordered before the second.

The following will sort from oldest to youngest:

bool CompareAges(const Information & left, const Information & right)
{
    return left.age > right.age;
}

std::sort(listOfPeople.begin(), listOfPeople.end(), CompareAges);

To select whether to sort ascending or descending, you can have two different calls to sort with different comparison functions, or you can create a functor class that has a flag determining how the items should be sorted.

struct CompareAgesUpOrDown
{
    CompareAgesUpOrDown(bool bDown) : m_bDown(bDown) {}
    bool operator() (const Information & left, const Information & right)
    {
        if (m_bDown)
            return left.age < right.age;
        else
            return left.age > right.age;
    }
    bool m_bDown;
};

bool bDown = ...;
std::sort(std::sort(listOfPeople.begin(), listOfPeople.end(), CompareAgesUpOrDown(bDown));

Answer 3

Others have already shown C++98/03 solutions. In C++11, you might want to use a lambda for your comparison instead:

// ascending age:
std::sort(people.begin(), people.end(), 
          [](person const &a, person const &b) { return a.age < b.age; });

// descending age:
std::sort(people.begin(), people.end(), 
          [](person const &a, person const &b) { return b.age < a.age; });

And, in case it should happen to arise:

// ascending name:
std::sort(people.begin(), people.end(), 
          [](person const &a, person const &b) { return a.name < b.name; });

// descending name:
std::sort(people.begin(), people.end(), 
          [](person const &a, person const &b) { return b.name < a.name; });

IMO, Information is too generic a name, so I've changed it to person. Contrariwise, listOfPeople puts too much emphasis on the form rather than the content (and, worse, it's just plain wrong, since you really have a vector of people, not a list at all). IMO, in programming, it's generally better to use list only to refer to a linked list, not to linear data structures in general.

Answer 4

You need to have a comparison function or object in order to use that sort. Take a look at the sort page at cplusplus.com for examples and information.

Here's a complete example using a comparison function:

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

class Information {
public:
  Information(int age, std::string name) : m_age(age), m_name(name) {}
  int age() const { return m_age; }
  std::string name() const { return m_name; }
private:
  int m_age;
  std::string m_name;

  friend bool sortInformationByAgeAscending(const Information& lhs, 
                                            const Information& rhs);      
  friend bool sortInformationByAgeDescending(const Information& lhs, 
                                             const Information& rhs);
};

bool sortInformationByAgeAscending(const Information& lhs, 
                                   const Information& rhs) {
  return lhs.m_age < rhs.m_age;
}

bool sortInformationByAgeDescending(const Information& lhs, 
                                    const Information& rhs) {
  return lhs.m_age > rhs.m_age;
}
int main (int argc, const char * argv[])
{
  std::vector<Information> info;
  info.push_back(Information(1, "Bill"));
  info.push_back(Information(5, "Ann"));
  info.push_back(Information(2, "Sue"));

  std::sort(info.begin(), info.end(), sortInformationByAgeAscending);

  std::cout << info.at(0).age() << ": " << info.at(0).name() << std::endl;
  std::cout << info.at(1).age() << ": " << info.at(1).name() << std::endl;
  std::cout << info.at(2).age() << ": " << info.at(2).name() << std::endl;

  return 0;
}

Answer 5

For descending sort you must overload > operator and not < then call sort with greater option like this : sort(listOfPeople.begin(), listOfPeople.end(), greater<Information>());

Answer 6

I would overload operator < and then sort using greater. Greater essentially means rhs < lhs. You then sort using sort(listOfPeople.begin(), listOfPeople.end(), greater<Information>());

If you decide to add operator< your class would play nicely with std::set and as a key in std::map in addition to allowing sort.

class Information {

private:
int age;
string name;

friend bool operator< (Information const& lhs, Information const& rhs){
    return lhs.age < rhs.age;
}

//etc, etc...
};