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

Question

如何初始化静态地图，其中值为 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

另一种方法是使用 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 并依赖于副本 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();
}

Answer 3

编写定制的 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>());

...除非有错别字。

Live example.

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

Initialize static std::map with unique_ptr as value

c++

initialization

unique-ptr

c++11