如何让C++包装类在特定构造时不初始化基类？

想要创建一个类似std::optional的包装类，通过继承实现向被包装类的无缝转换，该类仅处理类类型（简单类型由其他特化版本处理），用于返回值或表示无法返回结果，包装类会存储后续流程控制所需信息。

现有代码中，wrapper类继承自base类，用using声明继承基类构造函数，但默认构造函数希望不初始化基类——假初始化会带来不期望的副作用（比如示例里base的构造函数会递增计数器，而且未初始化的引用成员会导致未定义行为）。

问：能不能在保留继承带来的无缝转换特性的同时，让特定构造函数不初始化基类？

示例代码：

struct base { // 可以是任意类类型
    base(int& i1, int& i2) : a{i1}, b{i2} {
        ++counter;
    }

    int& a;
    int& b;

    static inline int counter {0};
};

class wrapper : public base { // 实际使用时会是模板类
public:
    bool valid {true};

    using base::base; // 用于var2的构造

    wrapper() : valid{false} {} // 用于var1，希望不初始化base
};

auto do_stuff(base b) { return b.a * b.b; }

int main() {
    int i = 1, j = 2;

    wrapper var1;

    if (var1.valid) {
        do_stuff(var1); // 不会执行
    }

    wrapper var2(i, j);

    if (var2.valid) {
        do_stuff(var2); // 会执行
    }
}

首先明确：直接继承基类的方式根本做不到“不初始化基类”的构造函数——C++规定派生类构造函数必须初始化所有基类子对象，除非基类有默认构造函数，但这里base没有，所以你现在的代码本身就是编译错误的。

要实现需求，有两种靠谱思路：

思路1：用变体类型存储+隐式转换 #

放弃直接继承，改用std::variant把“无效状态”和“有效基类对象”作为可选存储，再给wrapper加隐式转换运算符，照样实现无缝转换：

#include <variant>

struct invalid_tag {};

class wrapper {
    std::variant<invalid_tag, base> storage;
public:
    bool valid() const { return std::holds_alternative<base>(storage); }

    // 无效状态构造：完全不碰base
    wrapper() : storage(invalid_tag{}) {}

    // 转发基类的构造参数
    template<typename... Args>
    wrapper(Args&&... args) : storage(base(std::forward<Args>(args)...)) {}

    // 隐式转换到base&，实现无缝传递
    operator base&() { return std::get<base>(storage); }
    operator const base&() const { return std::get<base>(storage); }
};

这种方式既保留了无缝转换的特性，无效状态下也不会初始化base，完全避免了副作用，代码也相对简洁。

思路2：手动用placement new控制初始化 #

如果一定要贴近继承的感觉（比如依赖基类的某些特性），可以把基类对象存在字节数组里，手动控制构造和析构：

#include <cstddef>
#include <new>

class wrapper {
    unsigned char storage[sizeof(base)];
    bool valid {false};
public:
    // 无效状态构造：啥也不做，base完全没初始化
    wrapper() = default;

    // 有效状态：手动调用base的构造函数
    template<typename... Args>
    wrapper(Args&&... args) : valid(true) {
        new(storage) base(std::forward<Args>(args)...);
    }

    // 析构时手动销毁base（如果是有效状态）
    ~wrapper() {
        if (valid) {
            std::launder(reinterpret_cast<base*>(storage))->~base();
        }
    }

    // 拷贝、移动构造需要自己实现，这里先删掉避免默认生成出问题
    wrapper(const wrapper&) = delete;
    wrapper& operator=(const wrapper&) = delete;

    // 隐式转换到base&，模拟继承的无缝转换
    operator base&() { return *std::launder(reinterpret_cast<base*>(storage)); }
    operator const base&() const { return *std::launder(reinterpret_cast<const base*>(storage)); }

    // 对外暴露有效性状态
    bool is_valid() const { return valid; }
};

这种方式能模拟继承的无缝转换，但需要手动处理内存管理、拷贝移动等，代码复杂度高，容易出问题，除非有特殊需求不推荐用。

总结 #

直接继承的路子走不通，因为C++强制要求派生类必须初始化基类。要保留无缝转换同时避免无效状态下的基类初始化，要么用变体存储+隐式转换，要么用手动内存管理的方式。

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