使用unique_ptr作为值初始化static std :: map

Question

如何初始化静态映射，其中value是std::unique_ptr ？

static void f()
{
    static std::map<int, std::unique_ptr<MyClass>> = {
        { 0, std::make_unique<MyClass>() }
    };
}

当然这不起作用（删除了std::unique_ptr copy-ctor）。

可能吗？

Answer 1

问题是从std::initializer-list构造复制其内容。 （ std::initializer_list中的对象本质上是const ）。 要解决您的问题：您可以从单独的函数初始化地图...

std::map<int, std::unique_ptr<MyClass>> init(){
    std::map<int, std::unique_ptr<MyClass>> mp;
    mp[0] = std::make_unique<MyClass>();
    mp[1] = std::make_unique<MyClass>();
    //...etc
    return mp;
}

然后打电话给它

static void f()
{
    static std::map<int, std::unique_ptr<MyClass>> mp = init();
}

看到Live On Coliru

Answer 2

编写定制的crestion代码似乎很无聊，并且妨碍了清晰度。

这是相当有效的通用容器初始化代码。 它将您的数据存储在一个临时的std::array就像初始化列表一样，但它会移出而不是使它成为const 。

make_map采用偶数个元素，第一个是第二个值的键。

template<class E, std::size_t N>
struct make_container_t{
  std::array<E,N> elements;
  template<class Container>
  operator Container()&&{
    return {
      std::make_move_iterator(begin(elements)),
      std::make_move_iterator(end(elements))
    };
  }
};
template<class E0, class...Es>
make_container_t<E0, 1+sizeof...(Es)>
make_container( E0 e0, Es... es ){
  return {{{std::move(e0), std::move(es)...}}};
}

namespace details{
  template<std::size_t...Is, class K0, class V0, class...Ts>
  make_container_t<std::pair<K0,V0>,sizeof...(Is)>
  make_map( std::index_sequence<Is...>, std::tuple<K0&,V0&,Ts&...> ts ){
    return {{{
      std::make_pair(
        std::move(std::get<Is*2>(ts)),
        std::move(std::get<Is*2+1>(ts))
      )...
    }}};
  }
}
template<class...Es>
auto make_map( Es... es ){
  static_assert( !(sizeof...(es)&1), "key missing a value?  Try even arguments.");
  return details::make_map(
    std::make_index_sequence<sizeof...(Es)/2>{},
    std::tie( es... )
  );
}

这应该减少到：

static std::map<int, std::unique_ptr<MyClass>> bob = 
  make_map(0, std::make_unique<MyClass>());

...禁止错别字。

实例 。

Answer 3

另一种方法是使用lambda。 它与使用单独的函数相同，但使地图的初始化更接近于动作。 在这种情况下，我使用了auto和decltype的组合，以避免必须命名地图的类型，但这只是为了好玩。

请注意，传递给lambda的参数是对在调用点尚未构造的对象的引用，因此我们不能以任何方式引用它。 它仅用于类型扣除。

#include <memory>
#include <map>
#include <utility>

struct MyClass {};


static auto& f()
{
  static std::map<int, std::unique_ptr<MyClass>> mp = [](auto& model)
  {
    auto mp = std::decay_t<decltype(model)> {};
    mp.emplace(0, std::make_unique<MyClass>());
    mp.emplace(1, std::make_unique<MyClass>());
    return mp;
  }(mp);
  return mp;
}

int main()
{
  auto& m = f();
}

这是另一种方式。 在这种情况下，我们将一个临时文件传递给lambda并依赖于copy elision / RVO。

#include <memory>
#include <map>
#include <utility>

struct MyClass {};

static auto& f()
{
  static auto mp = [](auto mp)
  {
    mp.emplace(0, std::make_unique<MyClass>());
    mp.emplace(1, std::make_unique<MyClass>());
    return mp;
  }(std::map<int, std::unique_ptr<MyClass>>{});
  return mp;
}

int main()
{
  auto& m = f();
}

另一种方法是，在可变lambda中使用lambda捕获。

#include <memory>
#include <map>
#include <utility>

struct MyClass {};

static auto& f()
{
  static auto mp = [mp = std::map<int, std::unique_ptr<MyClass>>{}]() mutable
  {
    mp.emplace(0, std::make_unique<MyClass>());
    mp.emplace(1, std::make_unique<MyClass>());
    return std::move(mp);
  }();
  return mp;
}

int main()
{
  auto& m = f();
}