Question

想象一下这样的代码：

std::unordered_map<std::string, std::function<Foo *()>> FooFactory;
void registerFoo(std::string name, std::function<Foo *()> factory)
{
    FooFactory.emplace(name, factory);
}

如果我现在会在另一个文件中编写这样的代码：

static bool Baz = [](){ registerFoo("baz", []() { return new BazFoo(); })}();

而另一个：

static bool Bar = [](){ registerFoo("bar", []() { return new BarFoo(); })}();

在这种情况下，当程序初始化时会调用registerFoo，但是FooFactory会被清零，因此注册的函数会消失。

有没有办法让这个工作以安全的，独立于编译器的方式工作（对于c ++ 14）？

Answer 1

您可以将工厂本身固定在一个功能中：

std::unordered_map<std::string, std::function<Foo *()>>& getFactory() {
    static std::unordered_map<std::string, std::function<Foo *()>> FooFactory;
    return FooFactory;
}

您的注册功能可以通过：

void registerFoo(std::string name, std::function<Foo *()> factory)
{
    getFactory().emplace(name, factory);
}

这应该保证订购。

Answer 2

虽然不鼓励使用这样的全局上下文，但除了@ Barry的回答之外，还应该考虑更多的项目：

您应该使用emplace保护mutex（如果多个线程尝试添加到unordered_map）
可选择返回emplace的成功参数（由second访问）。
转发您的论据以确保完美转发：

bool registerFoo(std::string &&name, std::function<Foo *()> &&factory)
{
    static std::mutex register_mutex;
    std::lock_guard<std::mutex> lock(register_mutex);

    return getFactory().emplace(
            std::forward<std::string>(name),
            std::forward<std::std::function<Foo *()>>(factory)
        ).second;
}

然后：

static bool Baz = [](){ return registerFoo("baz", []() { return new BazFoo(); })}();

当你不再需要它们时，不要忘记删除所有这些免费函数指针。

Answer 3

首先，您需要一些线程安全性：

@types/react

让我们有一个：

template<class T, class M=std::shared_timed_mutex> // shared_mutex in C++17
struct mutex_guarded {
  template<class F>
  auto write( F&& f )
  ->std::decay_t<std::result_of_t<F(T&)>> {
    auto l = lock();
    return std::forward<F>(f)(t);
  }
  template<class F>
  auto read( F&& f ) const
  ->std::decay_t<std::result_of_t<F(T const&)>> {
    auto l = lock();
    return std::forward<F>(f)(t);
  }
  mutex_guarded() {}
  template<class T0, class...Ts,
    std::enable_if_t<!std::is_same<std::decay_t<T0>, mutex_guarded>{},int> =0
  >
  mutex_guarded(T0&& t0, Ts&&...ts):
    t(std::forward<T0>(t0), std::forward<Ts>(ts)...)
  {}
  mutex_guarded( mutex_guarded const& o ):
    t(o.copy_from())
  {}
  mutex_guarded( mutex_guarded && o ):
    t(o.move_from())
  {}
  mutex_guarded& operator=(mutex_guarded const&)=delete;
  mutex_guarded& operator=(mutex_guarded &&)=delete;
  mutex_guarded& operator=(T const& t) {
    write([&t](T& dest){dest=t;});
    return *this;
  }
  mutex_guarded& operator=(T&& t) {
    write([&t](T& dest){dest=std::move(t);});
    return *this;
  }
private:
  T copy_from() const& { return read( [](T const& t){ return t; } ); }
  T copy_from() && { return move_from(); }
  T move_from() { return write( [](T& t){ return std::move(t); } ); }

  std::unique_lock<M> lock() const {
    return std::unique_lock<M>(m);
  }
  std::shared_lock<M> lock() {
    return std::shared_lock<M>(m);
  }
   M m; // mutex
   T t;
};

具有线程安全初始化，然后

using foo_factory = std::function<std::unique_ptr<Foo>()>;
using foo_factories = std::unordered_map<std::string, foo_factory>;
mutex_guarded<foo_factories>& get_foo_factories() {
  static mutex_guarded<foo_factories> map;
  return map;
}

是线程安全的，可以尽早保证工厂的初始化。

关闭时，工厂毁坏的时间超出了您的控制范围（相反的施工顺序），可能为时过早。

void registerFoo(std::string name, std::function<Foo *()> factory)
{
  get_foo_factories().write([](auto& f){f.emplace(name, factory);});
}

这会将它放在堆上的位置会更长一些。注意这也泄漏了工厂和地图;可以添加“足够晚”的手动销毁。请注意，这种破坏不是线程安全的，也不能廉价地使线程安全;它应该在清理完所有线程后发生。

Answer 4

为了避免静态初始化命令失败，您可以将工厂访问包装到第一次调用期间构造它的函数调用中：

using
t_NameToFactoryMap = std::unordered_map<std::string, std::function<Foo *()>>

t_NameToFactoryMap * p_foo_factory{}; // initialized with nullptr before dynamic initialization starts

t_NameToFactoryMap &
getFooFactory(void)
{
    if(!p_foo_factory)
    {
        p_foo_factory = new t_NameToFactoryMap{};
    }
    return(*p_foo_factory);
}

void registerFoo(std::string name, std::function<Foo *()> factory)
{
    getFooFactory().emplace(name, factory);
}

这种自动注册方法的缺点是，如果您决定在某些静态库项目中使用它们，它们将产生问题。使用此静态库的项目不会引用Baz或Bar，除非它们使用某些依赖于编译器的标志链接此静态库，例如gcc的--whole-archive。

因此，更好的解决方案是在main下明确创建工厂并注册所有必需的项目，而不处理动态初始化。

在C ++中，我可以使用来自不同文件的值安全地初始化unordered_map吗？

4 个答案: