std::sort

To use the STL sort algorithm on a container, the type used by the container should define a less-than operator.

But what if we are required to order the container in different ways? We could pass to sort a predicate that defines our specific less-than operator.

If we are not using boost or C++0x usually this means we create a specific functor just for that.

Here we see an example to accomplish this task using boost::bind or a lambda expression:

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

#include "boost/bind.hpp"

using namespace std;

namespace
{
  class PersonalInfo
  {
    string name_;
    string surname_;
    unsigned int age_;

  public:
    PersonalInfo(const string& n, const string& s, unsigned int age) : 
      name_(n), surname_(s), age_(age) {}

      string name() const { return name_; }

      string surname() const { return surname_; }

      unsigned int age() const { return age_; }

      // 1. define the operator less-than based on the first name
      friend bool operator< (const PersonalInfo& lhs, const PersonalInfo& rhs)
      { return lhs.name_ < rhs.name_; }

  };

  // 2. 
  ostream& operator<< (ostream& os, const PersonalInfo& pi)
  {
    os << pi.name() << ' ' << pi.surname() << ' ' << pi.age() << endl;
    return os;
  }

  void dump(vector<PersonalInfo>& vec)
  {
    copy(vec.begin(), vec.end(), ostream_iterator<PersonalInfo>(cout));
    cout << endl;
  }
}

void bind03()
{
  vector<PersonalInfo> vec;
  vec.push_back(PersonalInfo("Little", "John", 30));
  vec.push_back(PersonalInfo("Friar", "Tuck", 50));
  vec.push_back(PersonalInfo("Robin", "Hood", 40));
  dump(vec);

  cout << "Default sorting (by name):" << endl;
  sort(vec.begin(), vec.end()); // 3.
  dump(vec);

  cout << "By age:" << endl; // 4.
  sort(vec.begin(), vec.end(), boost::bind(
    less<unsigned int>(),
    boost::bind(&PersonalInfo::age, _1),
    boost::bind(&PersonalInfo::age, _2)));
  dump(vec);

  cout << "By surname:" << endl;
  sort(vec.begin(), vec.end(), boost::bind(
    less<string>(),
    boost::bind(&PersonalInfo::surname, _1),
    boost::bind(&PersonalInfo::surname, _2)));
  dump(vec);

  cout << "Using Lambda, sorting by age:" << endl; // 5.
  auto fa = [](PersonalInfo p1, PersonalInfo p2) { return less<unsigned int>()(p1.age(), p2.age()); };
  sort(vec.begin(), vec.end(), fa);
  dump(vec);

  cout << "Using Lambda, sorting by surname:" << endl;
  auto fs = [](PersonalInfo p1, PersonalInfo p2) { return less<string>()(p1.surname(), p2.surname()); };
  sort(vec.begin(), vec.end(), fs);
  dump(vec);
}

1. since we define the operator less-than for this class, it is possible sort its objects
2. let's the ostream know how to print it
3. first call to sort(), using the default less-than operator
4. let's use boost::bind to create a ordering predicate on the fly. We use the STL less functor passing it the two elements in the sequence that the sort algorithm provides
5. same as 4., but using C++0x lambda expressions. It is not necessary storing the lambda expression in a local variable, but it looks to me in this way the code is a bit more readable; and if you use the cool C++0x feature of type inference, by the keyword auto, it is neat and clear.

The code is based on an example provided by "Beyond the C++ Standard Library: An Introduction to Boost", by Björn Karlsson, an Addison Wesley Professional book. An interesting reading indeed.