是否可以确保仅在“静态初始化”步骤期间调用函数

Question

我想知道是否可以确保仅在程序的静态初始化步骤中调用函数？

例如，假设我有一些单例类，它包含一个 std::map 对象并公开了它的 insert 和 at 方法。我想确保从中读取数据（at 方法）是线程安全的，据我了解，这需要确保没有任何东西在修改数据（即使用 insert 方法）。

地图打算在静态初始化期间仅被填充，此时我假设只有一个线程。一旦main() 开始，我有什么方法可以确保没有误导用户调用insert？

---

示例代码

#include <map>
#include <string>

class Singleton {
  private:
    std::map<std::string, std::string> m_map;
  public:
    static Singleton& instance() {
      static Singleton theSingleton;
      return theSingleton;
    }
    static bool insert(const std::string& key, const std::string& value) {
      return instance().m_map.insert(std::make_pair(key, value) ).second;
    }
    static std::string at(const std::string& key) {
      return instance().m_map.at(key);
    }
};

static bool inserted = Singleton::insert("Hello", "World"); // fine

bool addItem(const std::string& key, const std::string& value) {
  return Singleton::insert(key, value); // not OK
}

---

不用说（？）实际代码比这个简单的例子要复杂得多。

---

解决方案后编辑：看起来尽可能安全的最佳方法是维护一个status 变量，该变量记录单例是处于“插入”还是“读取”模式并采取相应行动。感谢大家的意见和建议！

Answer 1

我猜您还想在设置应用程序时使用“at”方法。 为什么不添加一个“锁定”方法并在主函数中调用那个简单的函数呢？

#include <map>
#include <string>

class Singleton {
private:
    std::map<std::string, std::string> m_map;
    bool m_locked;
    Singleton() : m_locked(false) { }

public:
    static Singleton& instance() {
        static Singleton theSingleton;
        return theSingleton;
    }

    static void lock() {
        instance().m_locked = true;
    }

    static bool insert(const std::string& key, const std::string& value) {
        if (instance().m_locked) { return false; }
        return instance().m_map.insert(std::make_pair(key, value)).second;
    }
    static std::string at(const std::string& key) {
        return instance().m_map.at(key);
    }
};

static bool inserted = Singleton::insert("Hello", "World"); // fine

bool addItem(const std::string& key, const std::string& value) {
    return Singleton::insert(key, value); // not OK
}

int main(int argc, char** argv)
{
    Singleton::lock();
    Singleton::insert("Hello2", "World2"); // fails
    return 0;
}

Answer 2

如果你能保证用户在初始化阶段main()之前不会读到map，一种解决办法是构造一个静态map只做初始化，然后在构造singleton的时候把它移到singleton中。

由于构造是在第一次调用instance() 时发生的，因此您可以确定映射已正确初始化。

那么对insert 的其他调用将不会对单例产生影响。您还可以添加互斥锁来保护insert 以避免 UB 处于竞争状态。

class Singleton {
  private:
    std::map<std::string, std::string> m_map;
    static auto& init_map() {
        static std::map<std::string, std::string> m;
        return m;
    }
    Singleton() {
        m_map = std::move(init_map());
        init_map().clear();
    }
  public:
    static Singleton& instance() {
      static Singleton theSingleton;
      return theSingleton;
    }
    static bool insert(const std::string& key, const std::string& value) {
      // you can also add mutex to protect here,
      // because calling insert from different threads without
      // protection will screw up its internal state, even if
      // the init_map becomes useless after main
      return init_map().insert(std::make_pair(key, value) ).second;
    }
    static std::string at(const std::string& key) {
      return instance().m_map.at(key);
    }
};

Answer 3

就像 Jürgen 使用非 Java 方式但 c/c++ 方式创建单例（即命名空间）。

为什么要这样做：

• 在链接时优化更高效，更容易，因为无需取消引用 this 即可访问状态；
• 无需维护代码以确保唯一性：唯一性由链接器确保。

singleton.hpp

namespace singleton{
  void lock();
  bool instert(const std::string& key, const std::string& value);
  std::string at(const std::string& key)
  }

singleton.cpp

namespace singleton{
  namespace{
    inline decltype(auto) 
    get_map(){
      static std::map<std::string, std::string> m_map;
      return m_map;
      }
    bool m_locked=false; //OK guarenteed to happen before any dynamic initialization [basic.start.static]
    }

  void lock() {
    m_locked = true;
    }

  bool insert(const std::string& key, const std::string& value) {
    if (m_locked) { return false; }
    return get_map().insert(std::make_pair(key, value)).second;
    }

  std::string at(const std::string& key) {
    return get_map().at(key);
    }
  }

此外，如果必须在通用代码中使用单例，则可以使用结构体：

struct singleton_type{
  static void lock() {singleton::lock();}
  static auto insert(const std::string& key, const std::string& value) {
      return singleton::insert(key,value);
      }
  static auto at(const std::string& key) {
      return singleton::at(key,value);
      }
  };
auto x = singleton_type{};
auto y = singleton_type{}; 
// x and y refers to the same and unique object file!!!

明天，停止用 java 编码:)。