C++ C++；让两个子类共享其基类中的一个变量

假设我有3个类：Base、A和B

Base是a类和B类的基类

Base有一个变量val，a和B可以访问该变量

如果我可以通过类A设置val变量，并且它反映在类B中，我将如何使它工作

例如：

我知道下面的代码不起作用，因为我正在创建类型为a和b的对象

我想做的是让a和b共享同一个变量，这样无论何时

a

对它做了什么，它都会反映在

b

中

a aa;
b bb;

aa.SetVal(50000);
cout << aa.GetVal() << endl;
cout << bb.GetVal() << endl;

aa；
b-bb；
aa.SetVal（50000）；
cout那是一份供参考的工作，而不是课程。只需使用一个类
X
，并创建对对象的引用：

X  aa;
X& bb = aa;
aa.SetVal(50000);
std::cout << aa.GetVal() << std::endl;
std::cout << bb.GetVal() << std::endl;

现在，
aa
和
bb
共享同一个
S
对象，可以非常轻松地修改它。请注意，
A
和
B
的构造函数也应该存储
std:：shared\u ptr
：

class A { // and B
private:
    std::shared_ptr<S> s;
public:
    A(std::shared_ptr<S> as) : s(as) {}
};

与：

但一般来说，我会避免对象之间共享状态。大多数情况下，根据上下文的不同，您可以重构代码并消除共享依赖关系。
如果共享值在基类中是静态的，那么派生类的所有实例都将看到一个基类成员

如果该值不是静态的，则无论该值是否在基类中，类的每个实例都将有其自己的副本。
您可以将该成员设置为基类的静态成员，然后所有派生类都可以访问该成员，但是派生类中任何更改静态成员的对象都会为其他每个对象更改该成员

class Base
{
public:

    int GetVal()
    {
        return val;
    }

    void SetVal( int newVal )
    {
        val = newVal;
    }
private:

    static int val;
};

// Need to instantiate the static variable somewhere
int Base::val = 0;

class A : public Base
{};

class B : public Base
{};

类基{
静态int值；
公众：
虚拟~Base（）{}
void setVal（常量int&val）{
值=val；
}
int getVal（）常量{
返回值；
}
};
int Base:：value=0；
A类：公共基地{
};
B类：公共基地{
};
#包括
int main（）{
A A；
B B；
a、 setVal（20）；
std:：cout我不知道您想做什么。是否希望A和B的所有实例共享相同的值？如果是，请在基类中将其声明为静态。
如果没有，您想如何选择哪一个将共享该值？
您必须了解为
aa
和
bb
的基类子对象分配的成员的内存位置位于不同的内存位置。共享意味着从不同的位置访问相同的内存位置，这是您无法做到的使用标准继承实现，除非您选择操作静态基类成员-您现在可以在答案中看到关于后者的几个示例。问题是，这是正确的设计，并且您正在操作的值是否应该是“无实例”的值。我刚刚发布了一个编辑我的意思。我需要a类和b类访问相同的变量并对其进行更改。当你说，“a类和b类将执行不同的操作”，这是否意味着
A
和
B
实际上是不相关的类型？这仅仅是因为需要有相似的接口？是的，它们是不相关的类型。它们唯一需要的共同点是访问相同的变量。请看，不相关的类型不应该从公共
基继承。继承“is-a”模型关系-这意味着
A
和
B
将是共享公共属性的类型，因为它们相似。显然它们不相等，但它们都是
基
。仅为共享静态类成员而继承是糟糕的设计-实际上，我宁愿在这样的设计上使用隐藏良好的全局。如果我是呢每节课都需要（A和B）做不同的事情？@Sempus，如果两个完全不同的类共享相同的状态，那么您就做错了。阅读封装的相关内容，并尽可能保持您的类干净且彼此独立。主要目标是这两个类将做不同的事情，但需要能够访问和共享单个变量可以。太好了！我让它工作了。现在我只需要把它们移到不同的文件中，让它工作就行了。
int s = 0;
A aa(s);
B bb(s);

class A { // and B
private:
    int& s; // or any other type
public:
    A(int& as) : s(as) {}
};

class Base
{
public:

    int GetVal()
    {
        return val;
    }

    void SetVal( int newVal )
    {
        val = newVal;
    }
private:

    static int val;
};

// Need to instantiate the static variable somewhere
int Base::val = 0;

class A : public Base
{};

class B : public Base
{};

class Base {
    static int value;
public:
    virtual ~Base() { }

    void setVal(const int& val) {
        value = val;
    }

    int getVal() const {
        return value;
    }
};

int Base::value = 0;

class A : public Base {
};

class B : public Base {
};

#include <iostream>

int main() {
    A a;
    B b;
    a.setVal(20);
    std::cout << b.getVal(); // 20
}