sort the 'std::vector' containing classes

Question

Sort by using a binary predicate and std::sort

I need the sample for this...

Answer 1

Here is another adaptation of the example that uses two different kinds of predicates. The predicate specified can be a function pointer or a functor which is a class that defines operator() so that the object when instantiated can be used just like a function would be. Notice that I had to add one more header inclusion to the functional header. This is because the functor inherits from binary_function which is defined within the std library.

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

 using namespace std;

 class MyData
 {
  public:
    static bool compareMyDataPredicate(MyData lhs, MyData rhs) { return (lhs.m_iData <                        rhs.m_iData); }
    // declare the functor nested within MyData.
      struct compareMyDataFunctor : public binary_function<MyData, MyData, bool>
   {
      bool operator()( MyData lhs, MyData rhs)
        {
            return (lhs.m_iData < rhs.m_iData);
         }
    };

   int m_iData;
      string m_strSomeOtherData;
   };


 int main()
{
  // Create a vector that contents elements of type MyData
     vector<MyData> myvector;

       // Add data to the vector
        MyData data;
       for(unsigned int i = 0; i < 10; ++i)
       {
          data.m_iData = i;
          myvector.push_back(data);
       }

    // shuffle the elements randomly
       std::random_shuffle(myvector.begin(), myvector.end());

       // Sort the vector using predicate and std::sort.  In this case the predicate is     a static
       // member function.
      std::sort(myvector.begin(), myvector.end(), MyData::compareMyDataPredicate);

      // Dump the vector to check the result
    for (vector<MyData>::const_iterator citer = myvector.begin();
        citer != myvector.end(); ++citer)
   {
        cout << (*citer).m_iData << endl;
     }

   // Now shuffle and sort using a functor.  It has the same effect but is just a different
       // way of doing it which is more object oriented.
         std::random_shuffle(myvector.begin(), myvector.end());

       // Sort the vector using predicate and std::sort.  In this case the predicate is a functor.
         // the functor is a type of struct so you have to call its constructor as the third argument.
       std::sort(myvector.begin(), myvector.end(), MyData::compareMyDataFunctor());

    // Dump the vector to check the result
        for (vector<MyData>::const_iterator citer = myvector.begin();
        citer != myvector.end(); ++citer)
    {     
           cout << (*citer).m_iData << endl;
      }
    return 1;
   }

Answer 2

// alg_sort.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional>      // For greater<int>( )
#include <iostream>

// Return whether first element is greater than the second
bool UDgreater ( int elem1, int elem2 )
{
   return elem1 > elem2;
}

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator Iter1;

   int i;
   for ( i = 0 ; i <= 5 ; i++ )
   {
      v1.push_back( 2 * i );
   }

   int ii;
   for ( ii = 0 ; ii <= 5 ; ii++ )
   {
      v1.push_back( 2 * ii + 1 );
   }

   cout << "Original vector v1 = ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")" << endl;

   sort( v1.begin( ), v1.end( ) );
   cout << "Sorted vector v1 = ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")" << endl;

   // To sort in descending order. specify binary predicate
   sort( v1.begin( ), v1.end( ), greater<int>( ) );
   cout << "Resorted (greater) vector v1 = ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")" << endl;

   // A user-defined (UD) binary predicate can also be used
   sort( v1.begin( ), v1.end( ), UDgreater );
   cout << "Resorted (UDgreater) vector v1 = ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")" << endl;
}

Answer 3

std::sort(v.begin(), v.end(), predicate);

where predicate is a function with the following property:

User-defined predicate function object that defines the comparison criterion to be satisfied by successive elements in the ordering. A binary predicate takes two arguments and returns true when satisfied and false when not satisfied. This comparator function must impose a strict weak ordering on pairs of elements from the sequence.

( MSDN )

Eg:

bool strings_lt_by_first_char(std::string const &x, std::string const &y)
{
    return x[0] < y[0];
}