memfunc.cpp

Go to the documentation of this file.

 
#if defined (__IBMCPP__)
#  include <rw/_config.h>
   // disable implicit inclusion to work around 
   // a limitation in IBM VisualAge 5 (PR #26959) 
#  ifndef _RWSTD_NO_IMPLICIT_INCLUSION
#    define _RWSTD_NO_IMPLICIT_INCLUSION 
#  endif   // _RWSTD_NO_IMPLICIT_INCLUSION
#endif   // __IBMCPP__
 
#include <algorithm>   // for for_each, stable_sort
#include <cstddef>     // for size_t
#include <functional>  // for greater
#include <iomanip>     // for setprecision, setw
#include <ios>         // for fixed, left, right
#include <iostream>    // for cout
#include <vector>      // for vector
 
#include <examples.h>
 
 
// Very large city class
class Megapolis
{
public:
 
    Megapolis (const char *s = "", double n = 0)
        :population(n), cityName(s) { }
 
    // The following function cannot return void due to limitations in 
    // some current C++ implementations. 
    virtual std::size_t byPopulation () const {
        std::cout << std::setw (12) << std::left << cityName
                  << std::setw (12) << std::left << "Megapolis"
                  << std::setw (5) << std::right
                  << std::fixed << std::setprecision (1)
                  << population << '\n';
        return 0;
    }
 
    bool operator< ( const Megapolis* ptr_ ) {
        return population > ptr_->population;
    }
 
    double population;
 
protected:
 
    const char* cityName;
};
 
 
// City and surrounding area class
struct Metropolis: public Megapolis
{
    Metropolis (const char *s = "", double n = 0)
        : Megapolis (s, n){ }
 
    virtual std::size_t byPopulation () const {
        std::cout << std::setw (12) << std::left <<  cityName
                  << std::setw (12) << std::left << "Metropolis"
                  << std::setw (5) << std::right
                  << std::fixed << std::setprecision (1)
                  << population << '\n';
        return 0;
    }
};
 
 
namespace std {
 
// specialize the standard function object for Megapolis*
template<>
struct greater<Megapolis*>
{
    typedef const Megapolis* first_argument_type;
    typedef const Megapolis* second_argument_type;
    typedef bool             result_type;
 
    result_type
    operator() (first_argument_type x, second_argument_type y) const {
        return y->population < x->population;
    }
};
 
}   // namespace std
 
 
int main ()
{
    // Create a vector of very large cities
    std::vector<Megapolis*, std::allocator<Megapolis*> > cities;
 
    cities.push_back (new Megapolis ("Calcutta", 12));
    cities.push_back (new Megapolis ("Tokyo", 26.8));
    cities.push_back (new Megapolis ("Delhi", 10)); 
    cities.push_back (new Megapolis ("Bombay", 15));
  
    cities.push_back (new Metropolis ("Cairo", 12));
    cities.push_back (new Metropolis ("New York", 7.5));
    cities.push_back (new Metropolis ("Los Angeles", 3.7)); 
    cities.push_back (new Metropolis ("Jakarta", 8.2));
  
    // Now use mem_fun to pass byPopulation member function
    // of Megapolis to the for_each function.
    std::cout << "City        Type        Population (millions)\n";
    std::cout << "----------- ----------- ---------------------\n";
 
    std::for_each (cities.begin(), cities.end(),
                   std::mem_fun (&Megapolis::byPopulation));
 
    std::cout << "\nAfter sorting...\n\n";
 
    // Sort
    std::stable_sort (cities.begin (), cities.end (),
                      std::greater<Megapolis*>());
 
    std::for_each (cities.begin (), cities.end (),
                   std::mem_fun (&Megapolis::byPopulation));
 
    // Free allocated memory
    while (!cities.empty ()) {
        delete cities.back ();
        cities.pop_back ();
    }
 
    return 0;
}