将空向量放入std :: map（）

Question

How can I emplace an empty vector into a std::map ? For example, if I have a std::map<int, std::vector<int>> , and I want map[4] to contain an empty std::vector<int> , what can I call?

Answer 1

If you use operator[](const Key&) , the map will automatically emplace a value-initialized (ie in the case of std::vector , default-constructed ) value if you access an element that does not exist. See here:

http://en.cppreference.com/w/cpp/container/map/operator_at

(Since C++ 11 the details are a tad more complicated, but in your case this is what matters).

That means if your map is empty and you do map[4] , it will readily give you a reference to an empty (default-constructed) vector. Assigning an empty vector is unnecessary, although it may make your intent more clear.

Demo: https://godbolt.org/g/rnfW7g

Answer 2

Unfortunately the strictly-correct answer is indeed to use std::piecewise_construct as the first argument, followed by two tuples. The first represents the arguments to create the key (4), and the second represents the arguments to create the vector (empty argument set).

It would look like this:

map.emplace(std::piecewise_construct,   // signal piecewise construction
            std::make_tuple(4),         // key constructed from int(4)
            std::make_tuple());         // value is default constructed

Of course this looks unsightly, and other alternatives will work. They may even generate no more code in an optimised build:

This one notionally invokes default-construction and move-assignment, but it is likely that the optimiser will see through it.

map.emplace(4, std::vector<int>());

This one invokes default-construction followed by copy-assignment. But again, the optimiser may well see through it.

map[4] = {};

Answer 3

To ensure an empty vector is placed at position 4, you may simply attempt to clear the vector at position 4.

std::map<int, std::vector<int>> my_map;
my_map[4].clear();

As others have mentioned, the indexing operator for std::map will construct an empty value at the specified index if none already exists. If that is the case, calling clear is redundant. However, if a std::vector<int> does already exist, the call to clear serves to, well, clear the vector there, resulting in an empty vector.

This may be more efficient than my previous approach of assigning to {} (see below), because we probably plan on adding elements to the vector at position 4, and we don't pay any cost of new allocation this way. Additionally, if previous usage of my_map[4] indicates future usage, then our new vector will likely be eventually resized to the nearly the same size as before, meaning we save on reallocation costs.

---

Previous approach:

just assign to {} and the container should properly construct an empty vector there:

std::map<int, std::vector<int>> my_map;
my_map[4] = {};
std::cout << my_map.size() << std::endl; // prints 1

Demo

Edit: As Jodocus mentions, if you know that the std::map doesn't already contain a vector at position 4, then simply attempting to access the vector at that position will default-construct one, eg:

std::map<int, std::vector<int>> my_map;
my_map[4]; // default-constructs a vector there

Answer 4

What's wrong with the simplest possible solution? std::map[4] = {}; .

In modern C++, this should do what you want with no or at least, very little, overhead.

If you must use emplace , the best solution I can come up with is this:

std::map<int, std::vector<int>> map;
map.emplace(4, std::vector<int>());

Answer 5

Use piecewise_construct with std::make_tuple:

map.emplace(std::piecewise_construct, std::make_tuple(4), std::make_tuple());

We are inserting an empty vector at position 4.

And if there is a general case like, emplacing a vector of size 100 with 10 filled up then:

map.emplace(std::piecewise_construct, std::make_tuple(4), std::make_tuple(100, 10));

piecewise_construct : This constant value is passed as the first argument to construct a pair object to select the constructor form that constructs its members in place by forwarding the elements of two tuple objects to their respective constructor.