继承静态变量成员，但单独共享给各类继承类

Question

如果类继承具有静态变量成员的基类，则将是它们唯一一个与继承的所有类共享的成员。

我有几种继承类，并且每个类都有很多实例。 我希望每个继承类都有一个单独的静态成员，并与其所有实例共享。

怎么办呢？

谢谢你，对我糟糕的英语感到抱歉。

编辑：

class a{
static int var;};
class b::a{};
class c::a{};

现在，我希望 b 的所有实例都具有相同的 var ，并且 c 的所有实例都具有相同的 var ，但是 var b 的 var 与 c 的 var 不同。

我再次对我的英语感到抱歉，如果你能纠正我，请纠正我。

Answer 1

您可以使用 CRTP 来解决这个问题：

struct YourBaseBaseClass {
    // put everything that does not depend on your static variable
};

template <YourSubclass>
struct YourBaseClass : YourBaseBaseClass {
    static Member variable;
    // and everything that depend on that static variable.
};

struct AClass : YourBaseClass<AClass> {
     // there is a "variable" static variable here
};

struct AnotherClass : YourBaseClass<AnotherClass> {
     // which is different from the "variable" static variable here.
};

AClass 和 AnotherClass 都有一个 variable 静态变量（类型为 Member） ，但第一个是来自 YourBaseClass 的静态变量，另一个是来自 YourBaseClass 的静态变量，这是两个不同的类。

YourBaseBaseClass 是可选的，但如果您想使用 YourBaseBaseClass* 指针操作 AClass 和 AnotherClass，则需要它（你不能有 YourBaseClass* 指针，因为 YourBaseClass 不是一个类）。

并记住定义那些静态变量。

Answer 2

在这种情况下，您不能将静态成员放入基类中。但您可以尝试将其放在派生类中，并通过调用基类中的静态方法来访问它。因此 Derived 和 Derived2 的实例可以共享不同的静态成员。如果派生类的 GetStaticValue() 方法被调用，则强制派生类定义一个名为 value 的静态成员。

template <typename T>
class Base
{
public:

    static int GetStaticValue()
    {
        return T::value;
    }
};

class Derived : public Base<Derived>
{
    friend class Base<Derived>;
private:
    static int value;
};

int Derived::value = 1;

class Derived2 : public Base<Derived2>
{
    friend class Base<Derived2>;
private:
    static int value;
};

int Derived2::value = 2;

int main()
{
    Derived d;
    Derived da;
    int ret = d.GetStaticValue();
    ret = da.GetStaticValue();
    // As everything is static you don't need to instantiate the Derived classes
    ret = Base<Derived>::GetStaticValue(); 

    Derived2 d2;
    Derived2 d2a;
    ret = d2.GetStaticValue();
    ret = d2a.GetStaticValue();
}

Answer 3

静态成员与非静态成员不同。静态成员称为类变量，非静态成员称为实例变量。这是因为非静态成员属于特定对象（类的实例），而静态变量是共享的。

因此，静态成员不遵循相同的继承规则，并且仍然是定义它们的类的属性。