c++ - 依赖静态对象地址安全吗？

Question

假设我有这段代码:

#include <iostream>
#include <unordered_map>
#include <functional>

using const_string_ref = std::reference_wrapper<const std::string>;

namespace std
{
    template<>
    struct hash<const_string_ref>
    {
        size_t operator()(const const_string_ref& ref) const
        {
            return std::hash<std::string>()(ref);
        }
    };

    bool    operator==(const const_string_ref& lhs,
                       const const_string_ref& rhs)
    {
        return (lhs.get() == rhs.get());
    }
}

class test
{
public:
    void process(const std::string& action)
    {
        (this->*(ACTIONS_PROCESSORS_MAP_.at(action)))();
    }

private:
  using action_processor = void (test::*)();
  using actions_map = std::unordered_map<const_string_ref, action_processor>;

private:
  static const std::string FIRST_KEY_;
  static const std::string SECOND_KEY_;

  static const actions_map ACTIONS_PROCESSORS_MAP_;

private:      
  void first_action()
  {
      std::cout << "first works" << std::endl;
  }

  void second_action()
  {
      std::cout << "second works" << std::endl;
  }
};

const std::string test::FIRST_KEY_ = "first";
const std::string test::SECOND_KEY_ = "second";

const test::actions_map test::ACTIONS_PROCESSORS_MAP_ =
{{std::cref(FIRST_KEY_), &test::first_action},
 {std::cref(SECOND_KEY_), &test::second_action}};


int main()
{
   test t;

   t.process("first");
   t.process("second");

   return 0;
}

---

主要问题是:

我是否保证在进入 main 函数时，reference_wrapper 中包含的引用用作 test::ACTIONS_PROCESSORS_MAP_ 中的键将分别初始化为对 test::FIRST_KEY_ 和 test::SECOND_KEY_ 的有效引用，独立于静态顺序初始化？

这个问题可以更概括地概括为:

即使在这些对象初始化之前，指向静态对象的指针/引用是否有效(即地址是否可以在某个时候更改)？

Answer 1

是的，一旦分配了存储空间，您就可以安全地获取对象的地址，即使它还没有被初始化。静态对象的存储在程序运行期间持续，因此您可以随时获取地址。

当然，在其生命周期之外访问对象本身是不允许的。