如何正确初始化相互依赖的静态字段？

针对你的场景——需要在不同翻译单元实现互相持有依赖的静态T实例，同时避免静态初始化顺序问题和循环构造死锁，这里提供几种更简洁可靠的方案：

方案一：用指针存储依赖，延迟初始化（推荐，C++11+） #

核心思路是先构造空实例，再在getter中延迟设置依赖指针，避开构造时的循环调用。同时利用C++11开始的线程安全静态局部变量特性，保证初始化的原子性。

类定义（头文件T.h） #

class T {
public:
    // 静态getter，返回引用避免拷贝
    static T& A();
    static T& B();
    static T& C();

    // 对外提供获取依赖的接口
    const T& get_partner() const { return *partner_; }

private:
    // 私有构造，禁止外部创建实例
    T() = default;
    // 禁用拷贝和移动，保证单实例特性
    T(const T&) = delete;
    T& operator=(const T&) = delete;

    // 存储依赖的const指针，初始为nullptr
    const T* partner_ = nullptr;

    // 仅允许静态getter调用的初始化方法，保证依赖只设置一次
    void set_partner(const T* p) {
        if (!partner_) {
            partner_ = p;
        }
    }
};

分翻译单元实现 #

tu1.cpp（实现A）

#include "T.h"

T& T::A() {
    static T a; // 第一次调用时原子构造空实例
    if (!a.partner_) {
        // 调用B的getter，此时B会先完成自身构造，再设置依赖
        a.set_partner(&B());
    }
    return a;
}

tu2.cpp（实现B）

#include "T.h"

T& T::B() {
    static T b;
    if (!b.partner_) {
        b.set_partner(&A());
    }
    return b;
}

tu3.cpp（实现C，示例依赖A）

#include "T.h"

T& T::C() {
    static T c;
    if (!c.partner_) {
        c.set_partner(&A());
    }
    return c;
}

优势 #

• 完全避免静态初始化顺序问题：只有当第一次调用getter时，才会初始化对应实例
• 线程安全：C++11+的静态局部变量初始化是原子操作，不会出现多线程竞争问题
• 简洁可靠：无需额外的标记变量（如你之前用的b_once），依赖设置逻辑清晰
• 无拷贝开销：用指针存储引用，避免不必要的对象拷贝

方案二：持有常量副本（C++17+） #

如果你的需求是每个实例必须持有另一个实例的常量副本而非引用，可以用std::optional延迟构造副本，避开循环构造的问题：

类定义（头文件T.h） #

#include <optional>

class T {
public:
    static T& A();
    static T& B();
    static T& C();

    const T& get_partner() const { return partner_.value(); }

private:
    T() = default;
    T(const T&) = default; // 允许拷贝构造
    T& operator=(const T&) = delete;

    std::optional<const T> partner_;

    void set_partner(const T& p) {
        if (!partner_) {
            partner_.emplace(p); // 延迟构造副本
        }
    }
};

getter实现与方案一完全一致 #

唯一区别是set_partner会构造并存储依赖的副本，而非指针。

为什么你的原方案不够理想 #

你之前用静态标记变量b_once的方式存在几个问题：

1. 线程不安全：b_once的检查和赋值不是原子操作，多线程环境下可能出现多次赋值
2. 扩展性差：新增实例时需要额外维护标记变量，代码冗余
3. 破坏常量性：你不得不把T t设为非const成员，违背了“常量副本”的设计初衷

内容的提问来源于stack exchange，提问作者ChaosNe0