stdmap

Given std::map<int,std::string> myMap; fillMyMapWithStuff(myMap); // modify key values - I need to add a constant value to each key for (std::map<int,std::string>::iterator mi=myMap.begin(); mi != myMap.end(); ++mi) { // ... } Whats a good way apply some re-indexing? Must I remove the old entry and add a new one with the new key and old value? Looks like you are better off building a new map and swapping it afterward. You'll have only n insert operations instead of n deletions and n insertions. Yes, you have to remove the old entry and add a new one with the new key. Keys are not modifiable.

Is there a reason why passing a reference to a std::map as const causes the [] operator to break? I get this compiler error (gcc 4.2) when I use const: error: no match for ‘operator[]’ in ‘map[name]’ Here's the function prototype: void func(const char ch, std::string &str, const std::map<std::string, std::string> &map); And, I should mention that there is no problem when I remove the const keyword in front of std::map . If I've been instructed correctly, the [] operator will actually insert a new pair into the map if it doesn't find the key, which would of course explain why this happens, but

I'm attempting to declare a Row and a Column class, with the Row having a private std::map with values pointing to a templated Column . Something like this: template <typename T> class DataType { private: T type; }; template <typename T> class Field { private: T value; DataType<T> type; }; class Row { private: std::map<unsigned long,Field*> column; }; Well, I suppose in principle the Row class shouldn't have to know which kind of Field (or Column ) we'd like to use, i.e. whether it's a Field<int> in column 1 or a Field<double> in column 2. But I'm not sure what's the correct syntax for the Row

I would like to loop through an std::map and delete items based on their contents. How best would this be done? If you have a C++11-compliant compiler, here's an easy way to do this: std::map<K, V>::iterator itr = myMap.begin(); while (itr != myMap.end()) { if (ShouldDelete(*itr)) { itr = myMap.erase(itr); } else { ++itr; } } The idea is to walk the iterator forward from the start of the container to the end, checking at each step whether the current key/value pair should be deleted. If so, we remove the element iterated over using the erase member function, which then returns an iterator to

How to update the value of a key in std::map after using the find method? I have a map and iterator declaration like this: map <char, int> m1; map <char, int>::iterator m1_it; typedef pair <char, int> count_pair; I'm using the map to store the number of occurrences of a character. I'm using Visual C++ 2010. std::map::find returns an iterator to the found element (or to the end() if the element was not found). So long as the map is not const, you can modify the element pointed to by the iterator: std::map<char, int> m; m.insert(std::make_pair('c', 0)); // c is for cookie std::map<char, int>:

Assuming a map where you want to preserve existing entries. 20% of the time, the entry you are inserting is new data. Is there an advantage to doing std::map::find then std::map::insert using that returned iterator? Or is it quicker to attempt the insert and then act based on whether or not the iterator indicates the record was or was not inserted? The answer is you do neither. Instead you want to do something suggested by Item 24 of Effective STL by Scott Meyers : typedef map<int, int> MapType; // Your map type may vary, just change the typedef MapType mymap; // Add elements to map here int k

I am developing a multi threaded application, each thread will read (there will be no modifying of structures) from a group of maps and vectors. Can anyone please advise, since the threads are only reading from these structures would it be necessary to implement a sharable mutex around the code blocks where these structures are being read? alexrider In case of read only map/vector there is no need to use mutexes. This was already answered for both vector and map While C++03 doesn't mention threads, C++11 has clause covering you question. 23.2.2 Container data races [container.requirements