std::map prepare but do not insert

Question

I have an std:map defined as follows:

std:map<std::string country, std::vector<SomeClass> events>; 

Holds some events that will happen in some countries in the world.

I want my main function to create this map given a name to the key but without inserting a value. Let's say that the key is the name of a country. I want to create the "position" "USA" without inserting an event that will happen in the future.

My event() function will enter a new even without checking if the key is valid

Is this possible? Somehow to enter a value_pair with "empty" value?

UPDATE: No boost ...

Answer 1

Will inserting an empty vector do the trick?...

events.insert(std::make_pair("USA", std::vector<SomeClass>()));

You could then add actual events without checking of existence of map's value:

void event(const std::string& country, const SomeClass& data) {
    events[country].push_back(data);
}

I'm not sure whether this is what you're looking for, since the notion of 'creating "position" "USA"' looks ambiguous. (And earlier answers seem to pick different interpretation of it).

EDIT: As commenters pointed out, inserting the empty vector is not even necessary, since map values are automatically created (using default initializer) & inserted when one uses the [] operator. Hence you you can just do events["USA"].push_back(data) directly.

Answer 2

I think what you're looking for is std::multimap. This allows more than one value per key:

typedef std::multimap<std::string, SomeClass> EventMap;
typedef EventMap::value_type EntryType; // std::pair<..>

std::multimap<std::string, SomeClass> events;
// Add value
events.insert(std::make_pair("Norway", SomeClass(...)));

If you really need to be able mark a country as valid by inserting an empty placeholder I think that using a separate std::set probably would be a better solution. If you really want to do this, boost::optional or shared_ptr as mentioned by sehe is another solution.

Answer 3

Your question is somewhat unclear. You cannot insert a key without inserting a value as well. If this is really your intent, the answer is: No.

For your purpose I see no reason why you could not insert an empty vector instead (as others have pointed out). For actually doing this, you can do the insertion on initialisation of the map:

#include <string>
#include <map>
#include <initializer_list>
using namespace std;

class SomeClass { int x; };

int main() {
  SomeClass e1, e2, e3;
  map< string, vector<SomeClass> > events = // using initializer_list from c++0x  
  {
    {"USA",{e1,e2}}, {"CANADA",{ /* no events */ }, {"MEXICO",{e2,e3}}
  };
  // or later ...
  events["CUBA"] = {};
  events["RUSSIA"] = {e1,e2,e3};
}

Alternatively, you could return a default value if the key is not present when you ask for it, i.e. lazy initialization. The default behavior of the map is to add a new entry to the map using the default constructor of the value type whenever the requested key is missing. Which produces an empty vector<SomeClass> in this case. Therefore, I don't see what's wrong with this:

events["key that is missing beforehand"].push_back(e1);

If you actually want to avoid adding new entries to the map, you need to wrap your requests with something like:

string key = "USA";
vector<SomeClass> localEvents; // default, empty vector
// using the auto type from c++0x
auto ev = events.find(key);
if (ev == events.end()) // not found
  //events[key] = {}; // don't add the key to the map
  ;
else // get the corresponding vector
  localEvents = (*ev).second;

For this, you might also want to consider this related question: std::map default value

(The examples would work perfectly even without the c++0x features.)

Answer 4

The idiomatic solution(s) would be

typedef std::shared_ptr<SomeClass> element_t;
std::map<std::string, std::vector<element_t> >; 

Or

typedef boost::optional<SomeClass> element_t;
std::map<std::string, std::vector<element_t> > map; 

Then you could get it and use it like so:

if (map["USA"])
{
     SomeClass& use = *map["USA"];
     // ...
}