I'm puzzled about part of the standard. 23.1 states that items stored
in a container must be assignable. Therefore, the items in a map--that
is, std::pair<const Key, value> must be assignable. However, such a
pair--with the const Key--is not assignable.
My concern is more than academic; take for instance the following code
to make a copy of a map while eliminating some of the elements:
#include <map>
#include <algorithm>
typedef std::map<char, int> MapType;
bool predicate(const MapType::value_type& x)
{
return x.second > 1;
}
int main()
{
MapType bigMap;
bigMap['a'] = 1;
bigMap['b'] = 2;
MapType littleMap;
// This shouldn't work, right? Standard 23.1 says objects in
// container must be assignable, but MapType::value_type is
// std::pair<const char, int> which is NOT assignable
std::remove_copy_if(bigMap.begin(),
bigMap.end(),
std::inserter(littleMap, littleMap.end()),
&predicate);
return 0;
}
This compiles fine on g++ 4.1.2, but I want to make sure I'm not
writing nonstandard code. That leaves me with two questions:
1) is there part of the standard that I'm missing that describes how
maps can have values of std::pair<const Key, value> even though that
pair is not assignable?
2) is the sample code above standard compliant, and if not, how should
I accomplish something like this?
Consider assignable as x = y. The thing is that the key and the value must
be assignable, you need an assignment operator, either default or custom.
The reason being that values are loaded into the map using assignment. A
interface does. It is extremely easy to convert a non-const something to a
Notice the standard says objects in the container. That is refering to the