C++/Map Multimap/multimap insert

Insert value pair to int, double multimap

<source lang="cpp">

1. include <iostream>

using std::cout; using std::endl;

1. include <map>

int main() {

  std::multimap< int, double, std::less< int > > pairs; // declare the multimap pairs
  cout << "There are currently " << pairs.count( 15 )
     << " pairs with key 15 in the multimap\n";
  // insert two value_type objects in pairs
  pairs.insert( std::multimap< int, double, std::less< int > >::value_type( 15, 2.7 ) );
  pairs.insert( std::multimap< int, double, std::less< int > >::value_type( 15, 99.3 ) );
  cout << "After inserts, there are " << pairs.count( 15 )
     << " pairs with key 15\n\n";
  cout << endl;
  return 0;

} /* There are currently 0 pairs with key 15 in the multimap After inserts, there are 2 pairs with key 15

*/
       
   
 </source>

load the user-defined objects from vector into the multimap

<source lang="cpp">

1. include <algorithm>
2. include <functional>
3. include <iomanip>
4. include <iostream>
5. include <map>
6. include <string>
7. include <utility>
8. include <vector>

using namespace std; class PC {

  public:
  enum PC_type { Dell, HP, IBM, Compaq };
  PC( PC_type appliance = Dell, int model = 220,
     int serial = 0 );
  bool operator<( const PC& rhs ) const;
  PC_type appliance() const;
  int model() const;
  string name() const;
  void print() const;
  int serial() const;
  private:
  PC_type appliance_;
  int model_;
  int serial_;

}; inline PC::PC( PC::PC_type appliance, int model,

  int serial )
  : appliance_( appliance ), model_( model ), serial_( serial )

{} inline bool PC::operator<( const PC& rhs ) const { return appliance() < rhs.appliance() ||

  ( appliance() == rhs.appliance() && model() < rhs.model() );

} inline PC::PC_type PC::appliance() const { return appliance_; } inline int PC::model() const { return model_; } string PC::name() const {

  string what;
  switch( appliance() )
  {
     case Dell:     what = "Dell";              break;
     case HP:       what = "HP";                break;
     case IBM:      what = "IBM";               break;
     case Compaq:   what = "Compaq";            break;
     default:       what = "Unknown appliance"; break;
  }
  return what;

} inline void PC::print() const {

  char oldfill = cout.fill();
  cout << name() << " - Model "
       << model() << ", Serial number " 
       << serial() << endl;

} inline int PC::serial() const { return serial_; } bool greater_model( const pair<PC::PC_type,PC> p,int min_model ); int main( ) {

  const PC::PC_type kind[] = { PC::IBM,
     PC::IBM, PC::Dell, PC::HP,
     PC::HP, PC::HP };
  const int num_appliances = 3;
  vector<PC> v;
  for( int i = 0; i < num_appliances; ++i )
     v.push_back( PC( kind[i], i, i ) );
  map<int,PC> sold;
  transform( kind, kind+num_appliances, v.begin(),inserter( sold, sold.end() ),make_pair<int,PC> );
  map<int,PC>::const_iterator sold_end = sold.end();
  map<int,PC>::const_iterator site;
  for( site = sold.begin(); site != sold_end; ++site )
     site->second.print();
  // work with a multimap. key is appliance type, value is PC
  typedef multimap<PC::PC_type,PC> PC_multimap_type;
  PC_multimap_type stock;
  // appliance that customer desires
  const PC desired( PC::HP );
  cout << desired.name();
  // load the appliances into the multimap
  transform( kind, kind+num_appliances, v.begin(),inserter( stock, stock.end() ), make_pair<PC::PC_type,PC> );
  PC_multimap_type::const_iterator stock_end = stock.end();

} inline bool greater_model( const pair<PC::PC_type,PC> p,int min_model ) { return p.second.model() >= min_model; }

 </source>