C++中如何让派生类实例复用已存在的基类实例状态？

方案1：零开销引用绑定方案（无需继承base） #

如果你不需要保留derived继承base的多态能力，这个方案完全无额外开销，修改直接作用于原base实例：

struct base { int i = 1; };
struct derived final
{
    int& i; // 直接绑定原base实例的i成员
    int j = 2;
    // 构造时传入原base实例
    explicit derived(base& b) : i(b.i) {}
    
    void f() { 
        i = 2; // 访问语法完全不变，直接修改原b.i
    }
};

使用方式完全匹配需求：

base b; // b.i == 1
{
    derived d(b);
    d.f(); // 执行后b.i直接变为2，无额外拷贝
}
// 此时b.i已经是2

这个方案完全避免了你提到的base&成员需要写b.i的问题，i的访问语法和原继承写法完全一致。

方案2：保留继承层次的自动同步方案 #

如果你必须保留derived继承base的层次（比如要适配其他接收base引用/指针的接口），可以在derived的构造和析构中自动完成状态同步，上层完全无感知：

#include <utility>
struct base { int i = 1; };
struct derived final : public base
{
    int j = 2;
private:
    base& origin_;
public:
    explicit derived(base& src) : base(src), origin_(src) {}
    // 析构时自动将修改后的base状态同步回原实例
    ~derived() {
        origin_ = std::move(*static_cast<base*>(this));
    }
    void f() { 
        i = 2; // 访问语法完全不变
    }
};

使用方式同上，出作用域时自动同步，不需要手动写拷贝回base的逻辑。因为derived生命周期极短，移动赋值的开销可以忽略，大多数优化器会直接把这个拷贝优化掉，等效于直接修改原实例。

适配嵌套函数需求的写法 #

针对你提到的模拟嵌套函数、分离声明与实现的需求，可以用上述方案扩展，完全匹配你给出的伪代码效果：

struct s final
{
    int i = 1;
    // 对应f的嵌套函数g的实现类
    struct f_context final {
        int& i;
        int j = 2;
        explicit f_context(s& owner) : i(owner.i) {}
        void g(); // 声明放在类内，实现可以写在外部
    };

    void f()
    {
        f_context ctx(*this);
        ctx.g(); // 调用嵌套函数
    }
};

// 嵌套函数g的实现和声明分离，完全符合要求
void s::f_context::g() {
    i = 10; // 直接修改外层s实例的i
    j = 20; // 访问本地j变量
}

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