Re: unordered_map::emplace in C++0x
On 29 Apr., 07:38, Scott Meyers wrote:
C++0x's unordered_map supports emplacement via this member function
(from the FDIS):
template <class... Args>
pair<iterator, bool> emplace(Args&&... args);
Now, somehow emplace's implementation has to figure out which elements
of args correspond to the unordered_map's key and which to the mapped
data.
I don't think so. args is just forwarded to the value_type's
constructor. The value_type is a pair<const key_type, mapped_type>. To
see what we can pass as arguments to a map's emplace function we just
need to check what kind of constructors this value_type has. A pair
offers the following constructors:
- default constructor
- constructor taking two args that are forwarded
- conversion constructors from other pair types
- a piecewise_construct constructor
(taking three arguments, a dummy tag and two tuples)
The last one is interesting as it allows us to explicitly say which
arguments are used to construct the first member and which arguments
are used to construct the second. Example:
struct mykey {
...
mykey(int,int);
...
};
struct mymapped {
...
mymapped(int,double,string);
...
};
int main() {
using namespace std;
map<mykey,mymapped> themap;
themap.emplace(piecewise_construct,
forward_as_tuple(23,42),
forward_as_tuple(99,3.1415,"hello") );
}
where forward_as_tuple packs the arguments into "reference tuples"
while preserving their value category. That is, forward_as_tuple(99)
yields a tuple<int&&> and forward_as_tuple(some_int_variable) yields a
tuple<int&>. This function template used to be called "pack_arguments"
in earlier drafts.
In the emplace function template this is simply forwarded to the pair
constructor. No need to do anything special in the (unordered_)map
implementation.
Cheers!
SG