C++中能否无需逐个复制成员从父类实例创建子类实例？

一、通用场景需求 #

我需要实现这样的逻辑：从一个父类实例创建派生类实例，不想手动逐个复制父类的所有成员，而且希望父类新增或修改成员时，这段创建代码不用跟着改。预期的代码结构如下：

class A
{
public:
    A(/* 构造参数 */) {}

    SomeTypeA m_a;
    SomeTypeB m_b;
    // ...
    SomeTypeZ m_z;
};

class B : public A
{
public:
    B(A instanceOfA, bool someValueB)
    {
        // 这里希望一键完成父类所有成员的复制，而不是手动写m_a = instanceOfA.m_a这类代码
        valueB = someValueB;
    }
    void set() { valueB = true; }
    void unset() { valueB = false; }

private:
    bool valueB;
};

extern A instanceOfA;

B instanceOfB = B(instanceOfA, false);
...
instanceOfB.set();

二、实际业务场景（XY问题） #

我真正想做的是：基于std::ostream派生一个自定义类，实现类似std::cout的功能，但额外支持静音控制。要求原有输出代码（比如mutableCout << someData << "," << someData;）完全不用修改，只需要在其他地方调用mutableCout.mute()就能暂停输出。

解决方案 #

1. 通用场景的实现：一键复制父类成员 #

完全可行，利用C++的基类拷贝构造初始化就能实现，不用手动复制每个成员：

class A
{
public:
    A(/* 构造参数 */) {}
    // 编译器会自动生成默认拷贝构造函数，也可以手动指定=default
    A(const A& other) = default;

    SomeTypeA m_a;
    SomeTypeB m_b;
    // ...
    SomeTypeZ m_z;
};

class B : public A
{
public:
    // 关键：先调用父类A的拷贝构造函数，一键初始化所有父类成员
    B(const A& instanceOfA, bool someValueB) 
        : A(instanceOfA), valueB(someValueB) {}

    void set() { valueB = true; }
    void unset() { valueB = false; }

private:
    bool valueB;
};

extern A instanceOfA;

// 使用示例
B instanceOfB(instanceOfA, false);
instanceOfB.set();

这里A(instanceOfA)会自动调用父类的拷贝构造函数，把父类实例的所有成员复制到派生类的父类部分。后续父类新增或修改成员，这段代码完全不用改动，编译器会自动处理。

如果父类没有默认拷贝构造函数，也可以用赋值的方式完成：

B(const A& instanceOfA, bool someValueB)
{
    // 强制转换为父类指针后赋值，同样一键复制所有成员
    *static_cast<A*>(this) = instanceOfA;
    valueB = someValueB;
}

2. 针对std::ostream派生的特殊实现 #

注意：std::ostream是不可拷贝的（拷贝构造函数被显式删除），所以不能直接用上面的方法。正确的做法是复用std::cout的输出缓冲区，实现静音控制：

#include <iostream>

class MutableOStream : public std::ostream
{
public:
    // 复用std::cout的缓冲区，和cout共享输出渠道
    MutableOStream() : std::ostream(std::cout.rdbuf()), muted(false) {}

    void mute() { muted = true; }
    void unmute() { muted = false; }

    // 重载<<运算符，根据静音状态决定是否输出
    template<typename T>
    MutableOStream& operator<<(const T& value)
    {
        if (!muted) {
            std::ostream::operator<<(value);
        }
        return *this;
    }

    // 处理endl这类操纵符的重载
    MutableOStream& operator<<(std::ostream& (*manip)(std::ostream&))
    {
        if (!muted) {
            std::ostream::operator<<(manip);
        }
        return *this;
    }

private:
    bool muted;
};

// 全局实例，直接替代std::cout使用
MutableOStream mutableCout;

// 使用示例
int main()
{
    mutableCout << "这段会正常输出" << std::endl;
    mutableCout.mute();
    mutableCout << "这段不会输出" << std::endl;
    mutableCout.unmute();
    mutableCout << "这段又会输出了" << std::endl;
    return 0;
}

这个实现完全满足需求：原有输出代码不用改，只需调用mute()/unmute()就能控制输出状态。

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