无默认构造函数时，如何将C++类成员初始化为类似null的状态？

#include <variant>   

class A {
   public:
   A() {};

   private:
   B b;

   std::variant<B, C> var;
};

class B {
   public:
   B(C c) : c(c) {};

   private:
   C c;
};

class C {
   public:
   C(int val) : val(val) {};

   private:
   int val;
};

由于类B无默认构造函数，且std::variant<B,C>因所含类型均无默认构造函数也无法默认构造，导致类A的默认构造函数编译失败。目前暂时没有b和var的初始值，计划在A的成员方法中对它们进行初始化。

已考虑三种方案：

• 为B、C添加默认构造函数，但会产生不必要的构造函数，且无法为std::variant这类非自定义类添加；
• 使用哑元值初始化，但这种方式不优雅，容易引发潜在bug；
• 使用指针，但不想采用这种方式，且尝试时出现异常（如向variant赋值指针时报错：value of type "C *" cannot be assigned to an entity of type variant）。

来自Java背景，想了解在不使用指针的情况下，是否存在类似null的初始化方式来解决无默认构造函数的问题？或者类设计本身存在缺陷，需要调整？

1. 用std::optional模拟"null"状态 #

这是最接近Java null语义的方案，std::optional可以表示值"存在"或"不存在"，无需默认构造函数即可默认初始化（初始为无值状态）。

修改类A的定义：

#include <variant>
#include <optional>

class A {
public:
    A() = default; // 可正常默认构造

    // 成员方法中初始化b和var
    void initB(const C& c) {
        b = std::make_optional<B>(c);
    }

    void initVarAsB(const C& c) {
        var = std::make_optional<std::variant<B, C>>(B(c));
    }

    void initVarAsC(int val) {
        var = std::make_optional<std::variant<B, C>>(C(val));
    }

private:
    std::optional<B> b;
    std::optional<std::variant<B, C>> var;
};

使用时需先检查std::optional是否有值，再访问内部对象，避免未初始化访问。

2. 调整类设计，强制构造时完成初始化 #

如果A在没有b和var有效状态的前提下不应该被创建，可移除A的默认构造函数，改为构造时传入初始化参数：

class A {
public:
    A(const C& bInitVal, std::variant<B, C> varInitVal)
        : b(bInitVal), var(std::move(varInitVal)) {}

private:
    B b;
    std::variant<B, C> var;
};

这种方式符合C++的RAII原则，保证对象始终处于有效状态，避免后续初始化的隐患。

3. 用std::aligned_storage手动管理存储（底层方案） #

若不想用std::optional，可通过std::aligned_storage预留内存，手动控制对象的构造与销毁。该方式较底层，需自行管理生命周期，仅适合特殊场景：

#include <variant>
#include <type_traits>
#include <stdexcept>

class A {
public:
    A() = default;

    ~A() {
        // 手动销毁已构造的对象
        if (bConstructed) {
            std::destroy_at(reinterpret_cast<B*>(&bStorage));
        }
        if (varConstructed) {
            std::destroy_at(reinterpret_cast<std::variant<B, C>*>(&varStorage));
        }
    }

    void initB(const C& c) {
        std::construct_at(reinterpret_cast<B*>(&bStorage), c);
        bConstructed = true;
    }

    void initVarAsB(const C& c) {
        std::construct_at(reinterpret_cast<std::variant<B, C>*>(&varStorage), B(c));
        varConstructed = true;
    }

    B& getB() {
        if (!bConstructed) {
            throw std::runtime_error("B未初始化");
        }
        return *reinterpret_cast<B*>(&bStorage);
    }

private:
    typename std::aligned_storage<sizeof(B), alignof(B)>::type bStorage;
    bool bConstructed = false;

    typename std::aligned_storage<sizeof(std::variant<B, C>), alignof(std::variant<B, C>)>::type varStorage;
    bool varConstructed = false;
};

从C++设计理念出发，对象应尽可能在构造时就处于有效状态，避免"半初始化"情况。如果A必须在无初始值的情况下被创建，std::optional是最安全且符合意图的选择；如果A的存在依赖b和var的有效状态，强制构造时初始化会更合理。

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