Insert in std::map without default empty constructor

I have instances of std::map<std::string,Foo> where I insert and fill data. The class Foo is default-constructible, default-copyable. Then I do it by this (simple) way:

std::map<std::string,Foo> data;
for(std::string const& key : keys)
{
  assert(data.count(key) == 0); // it's assumed that the keys not already exist
  Foo& foo = data[key];
  foo.fill(blahblah);
}

After refactoring, the class Foo lost the default empty constructor. What are the (simple) alternatives to insert and fill data ? For the moment, I replaced by this but I don't know if it's the best/simplier way to refactor the code:

std::map<std::string,Foo> data;
for(std::string const& key : keys)
{
  assert(data.count(key) == 0); // it's assumed that the keys not already exist
  Foo& foo = data.emplace(key, Foo(requirement)).first->second;
  foo.fill(blahblah);
}

I also think it could be possible with insert, insert_or_assign, emplace, emplace_hint, try_emplace. I'm a little bit lost with all the possibilities...

I'm interested in solutions for C++11 or C++17.

You can use std::map::emplace together with std::move in order to add an element of a class that lacks a default constructor. This can be done after it was initialized with fill(...).

Example:

#include <map>
#include <string>
#include <iostream>

struct Foo
{
    Foo(int n) : m_n(n) {}
    int m_n;
};

int main() 
{
    std::map<std::string, Foo> m;

    // Create a Foo and insert it:
    Foo foo{ 111 };
    // foo.fill(blahblah);
    m.emplace("aaa", std::move(foo));

    // Verify it was inserted properly:
    Foo& foo2 = m.at("aaa");
    std::cout << foo2.m_n << std::endl;
    return 0;
}

Output:

111

Live demo

Note that I used std::map::at to verify that the element was inserted properly (using operator[] will fail to compile due to Foo lacking a default ctor).

I would simply go with:

data.emplace(key, requirement)

or, since C++17, with

data.try_emplace(key, requirement)

Using try_emplace is generally better (see the question mentioned in the other answer); however, ASAIK, in your case, both options are effectively the same.

From here

> A call to this function is equivalent to:
>
> (*((this->insert(make_pair(k,mapped_type()))).first)).

So the literal replacement for the operator[] in this case would be using insert function. However, I would suggest using emplace in order to avoid additional construction of std::pair, which insert function accepts as argument.

Since C++17, you can use try_emplace except very subtle cases. You can refer to this discussion in order to see if preferring emplace over try_emplace applies to you case.