C++设计问题：如何实现两个类共享一组变量的最优方式？

这个问题其实是面向对象设计里很典型的共享状态管理场景，你的思路里踩了继承的坑——确实，继承在这里完全不合适，因为每个子类实例都会持有父类的独立副本，根本做不到状态共享。下面给你几个靠谱的方案，按推荐优先级排序：

1. 最优解：共享状态对象 + 依赖注入 #

核心思路是用组合替代继承：把需要共享的x和y封装到一个独立的状态类里，然后让Class A和Class B都持有这个状态对象的引用（而不是继承它）。这样不管A还是B修改状态，操作的都是同一个实例，自然能同步更新。

这种方式的好处是：封装性好、灵活性高（比如以后需要多组独立的共享状态，只要创建多个状态对象就行），还方便单元测试。

代码示例（Java） #

首先定义共享状态类：

public class SharedState {
    private int x;
    private int y;

    // 构造器、Getter/Setter
    public SharedState(int initialX, int initialY) {
        this.x = initialX;
        this.y = initialY;
    }

    public int getX() { return x; }
    public void setX(int newX) { this.x = newX; }
    public int getY() { return y; }
    public void setY(int newY) { this.y = newY; }
}

然后实现Class A和Class B，通过构造器注入共享状态对象：

public class ClassA {
    private final SharedState sharedState;

    // 注入状态对象，而不是自己创建
    public ClassA(SharedState sharedState) {
        this.sharedState = sharedState;
    }

    public void updateX(int newX) {
        sharedState.setX(newX);
    }

    public void printCurrentState() {
        System.out.println("Class A: x=" + sharedState.getX() + ", y=" + sharedState.getY());
    }
}

public class ClassB {
    private final SharedState sharedState;

    public ClassB(SharedState sharedState) {
        this.sharedState = sharedState;
    }

    public void updateY(int newY) {
        sharedState.setY(newY);
    }

    public void printCurrentState() {
        System.out.println("Class B: x=" + sharedState.getX() + ", y=" + sharedState.getY());
    }
}

使用效果 #

public class Main {
    public static void main(String[] args) {
        // 创建一个共享状态实例
        SharedState state = new SharedState(10, 20);
        
        // 让A和B持有同一个状态对象
        ClassA a = new ClassA(state);
        ClassB b = new ClassB(state);

        a.printCurrentState(); // 输出：Class A: x=10, y=20
        b.printCurrentState(); // 输出：Class B: x=10, y=20

        // A修改x，B能立刻看到变化
        a.updateX(100);
        b.printCurrentState(); // 输出：Class B: x=100, y=20

        // B修改y，A也能看到变化
        b.updateY(200);
        a.printCurrentState(); // 输出：Class A: x=100, y=200
    }
}

多线程场景补充

如果你的代码是多线程环境，要保证线程安全，可以给SharedState的方法加synchronized，或者用原子类：

import java.util.concurrent.atomic.AtomicInteger;

public class ThreadSafeSharedState {
    private final AtomicInteger x = new AtomicInteger();
    private final AtomicInteger y = new AtomicInteger();

    public ThreadSafeSharedState(int initialX, int initialY) {
        x.set(initialX);
        y.set(initialY);
    }

    public int getX() { return x.get(); }
    public void setX(int newX) { x.set(newX); }
    // y同理
}

2. 备选：单例状态类（适合全局唯一共享） #

如果你的x和y是全局唯一的（整个程序里只有这一组），可以把SharedState做成单例类，让A和B直接获取这个单例实例。但要注意单例的线程安全问题，而且这种方式灵活性差，没法支持多组独立状态。

代码示例 #

public class SingletonSharedState {
    // 懒汉式单例（线程安全版）
    private static volatile SingletonSharedState instance;
    private int x;
    private int y;

    private SingletonSharedState() {}

    public static SingletonSharedState getInstance() {
        if (instance == null) {
            synchronized (SingletonSharedState.class) {
                if (instance == null) {
                    instance = new SingletonSharedState();
                }
            }
        }
        return instance;
    }

    // Getter/Setter...
}

然后Class A和B直接调用SingletonSharedState.getInstance()来访问x和y。

3. 不推荐的方案（你的初始思路问题） #

• 继承父类C：正如你发现的，每个子类实例都会创建父类的独立副本，状态完全隔离，根本做不到共享，直接pass。
• 友元类（C++）：虽然能让A直接访问B的私有成员（反之亦然），但彻底破坏了封装性，代码耦合度极高，后期维护会非常痛苦，不推荐。
• 静态变量：如果把x、y放在父类C的静态字段里，虽然能实现共享，但静态变量是类级别的，没法支持多组独立状态，而且全局静态变量会导致代码耦合，测试困难。

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