stdmap

I want to put two (not more) different data types as values into a map as shown in the following example: typeX A, B, ...; typeY Z, Y, ...; void func (typeX) { ... } void func (typeY) { ... } std::map <std::string, what_to_put_here??> map; map["a"] = A; map["z"] = Z; ... std::vector<std::string> list; // This list will be something like "a", "y", ... for (unsigned int i = 0; i < list.size(); ++i) func( map[list[i]] ) Obviously this doesn't work, as the map will only accept one data type of value. However, when looping over list , the call to func() should be unambiguous since the type of map

Is reference to object in std::map is thread safe? std::map< std::string, Object > _objects; map can be changed from many threads and this access is synchronized, but reference to value (Object &) accessable just from 1 instance and thread. is write operations with Object & is safe if another thread will add items to map? will it reallocate? The C++11 standard guarantees that const method access to containers is safe from different threads (ie, both use const methods). In addition, [container.requirements.dataraces] states implementations are required to avoid data races when the contents of

Is there a Java Map keySet() equivalent for C++'s std::map ? The Java keySet() method returns "a set view of the keys contained in this map." All of the answers presented thus far end up creating a std::set directly, which may not be ideal: if you only want to be able to iterate over the keys, you don't want to have the overhead of creating a whole new container. A more flexible option would be to use a transform iterator that converts a std::map iterator into some type of iterator that just yields the key when dereferenced. This is rather straightforward using the Boost Transform Iterator:

I have a map and I want to find the minimum value (right-hand side) in the map. Here is how I did it: bool compare(std::pair<std::string ,int> i, pair<std::string, int> j) { return i.second < j.second; } //////////////////////////////////////////////////// std::map<std::string, int> mymap; mymap["key1"] = 50; mymap["key2"] = 20; mymap["key3"] = 100; std::pair<char, int> min = *min_element(mymap.begin(), mymap.end(), compare); std::cout << "min " << min.second<< " " << std::endl; The code above works fine and I'm able to get the minimum value. However, when I put this code inside my class as

I am trying to assign a custom type as a key for std::map . Here is the type which I am using as key. struct Foo { Foo(std::string s) : foo_value(s){} bool operator<(const Foo& foo1) { return foo_value < foo1.foo_value; } bool operator>(const Foo& foo1) { return foo_value > foo1.foo_value; } std::string foo_value; }; When used with std::map , I am getting the following error. error C2678: binary '<' : no operator found which takes a left-hand operand of type 'const Foo' (or there is no acceptable conversion) c:\program files\microsoft visual studio 8\vc\include\functional 143 If I change the

Is there a way in C++ to search for the mapped value (instead of the key) of a map, and then return the key? Usually, I do someMap.find(someKey)->second to get the value, but here I want to do the opposite and obtain the key (the values and keys are all unique). Because of how a map is designed, you'll need to do the equivalent of a search on unordered data. for (it = someMap.begin(); it != someMap.end(); ++it ) if (it->second == someValue) return it->first; Pavan Chandaka Using lambdas (C++11 and newer) //A MAP OBEJCT std::map<int, int> mapObject; //INSERT VALUES mapObject.insert(make_pair(1,

Given that I have two std::map s, say: map<int, double> A; map<int, double> B; I'd like to get the intersection of the two maps, something of the form: map<int, pair<double,double> > C; Where the keys are the values in both A and B and the value is a pair of the values from A and B respectively. Is there a clean way using the standard-library? Mark Ransom template<typename KeyType, typename LeftValue, typename RightValue> map<KeyType, pair<LeftValue, RightValue> > IntersectMaps(const map<KeyType, LeftValue> & left, const map<KeyType, RightValue> & right) { map<KeyType, pair<LeftValue,