如果我有类似的东西
class Base {
static int staticVar;
}
class DerivedA : public Base {}
class DerivedB : public Base {}
DerivedA 和 DerivedB 会共享同一个 staticVar，还是各自拥有自己的？
如果我想让他们每个人都有自己的，你会建议我做什么？
【问题讨论】：
标签： c++ inheritance static
它们将共享相同的staticVar 实例。
为了让每个派生类都有自己的静态变量，您需要声明另一个具有不同名称的静态变量。
然后，您可以在基类中使用一对虚拟函数来获取和设置变量的值，并在每个派生类中覆盖该对，以获取和设置该类的“本地”静态变量。或者，您可以使用返回引用的单个函数：
class Base {
static int staticVarInst;
public:
virtual int &staticVar() { return staticVarInst; }
}
class Derived: public Base {
static int derivedStaticVarInst;
public:
virtual int &staticVar() { return derivedStaticVarInst; }
}
然后您将其用作：
staticVar() = 5;
cout << staticVar();
【讨论】：
virtual int &staticVar() { return Derived::staticVarInst; }
为确保每个类都有自己的静态变量，您应该使用"Curiously recurring template pattern" (CRTP)。
template <typename T>
class Base
{
static int staticVar;
};
template <typename T> int Base<T>::staticVar(0);
class DerivedA : public Base<DerivedA> {};
class DerivedB : public Base<DerivedB> {};
【讨论】：
他们将共享同一个实例。
您需要为每个子类声明单独的静态变量，或者您可以考虑一个简单的静态映射，您可以在其中存储派生类引用的变量。
编辑：可能的解决方案是将您的基类定义为模板。在这个模板中定义一个静态变量意味着每个派生类都有它自己的静态实例。
【讨论】：
Derived 的模板。相反，在这种情况下，它是template<typename> struct Base { static int staticVar; protected: ~Base() { } }; template<typename D> int Base<D>::staticVar; struct DerivedA : Base<DerivedA> { }; struct DerivedB : Base<DerivedB> { };。现在有两个静态变量，您可以使用DerivedB::staticVar 和DerivedA::staticVar 访问它们
在你的情况下只有一个staticVar：Base::staticVar
当你在一个类中声明一个静态变量时，这个变量是为那个类单独声明的。在您的情况下，DerivedA 甚至看不到 staticVar（因为它是私有的，不受保护或公共的），所以它甚至不知道存在 staticVar 变量。
【讨论】：
我知道这个问题已经得到解答，但我想提供一个静态成员继承的小例子。这是一种很好的方式来展示静态变量和相应的构造函数的有用性以及正在发生的事情。
FooBase.h
#ifndef FOO_BASE_H
#define FOO_BASE_H
#include <string>
class FooBase {
protected:
std::string _nameAndId;
private:
std::string _id;
static int _baseCounter;
public:
std::string idOfBase();
virtual std::string idOf() const = 0;
protected:
FooBase();
};
#endif // !FOO_BASE_H
FooBase.cpp
#include "FooBase.h"
#include <iostream>
int FooBase::_baseCounter = 0;
FooBase::FooBase() {
_id = std::string( __FUNCTION__ ) + std::to_string( ++_baseCounter );
std::cout << _id << std::endl;
}
std::string FooBase::idOfBase() {
return _id;
}
std::string FooBase::idOf() const {
return "";
} // empty
DerivedFoos.h
#ifndef DERIVED_FOOS_H
#define DERIVED_FOOS_H
#include "FooBase.h"
class DerivedA : public FooBase {
private:
static int _derivedCounter;
public:
DerivedA();
std::string idOf() const override;
};
class DerivedB : public FooBase {
private:
static int _derivedCounter;
public:
DerivedB();
std::string idOf() const override;
};
#endif // !DERIVED_FOOS_H
DerivedFoos.cpp
#include "DerivedFoos.h"
#include <iostream>
int DerivedA::_derivedCounter = 0;
int DerivedB::_derivedCounter = 0;
DerivedA::DerivedA() : FooBase() {
_nameAndId = std::string( __FUNCTION__ ) + std::to_string( ++DerivedA::_derivedCounter );
std::cout << _nameAndId << std::endl;
}
std::string DerivedA::idOf() const {
return _nameAndId;
}
DerivedB::DerivedB() : FooBase() {
_nameAndId = std::string( __FUNCTION__ ) + std::to_string( ++DerivedB::_derivedCounter );
std::cout << _nameAndId << std::endl;
}
std::string DerivedB::idOf() const {
return _nameAndId;
}
main.cpp
#include "DerivedFoos.h"
int main() {
DerivedA a1;
DerivedA a2;
DerivedB b1;
DerivedB b2;
system( "PAUSE" );
return 0;
}
如果__FUNCTION__ 在您的构造函数中不适合您，那么您可以使用类似的东西来替换它，例如__PRETTY_FUNCTION__ 或__func__，或者手动输入每个类的名称:(。
【讨论】：
@einpoklum 给出的示例代码无法正常工作，因为缺少静态成员 foo_ 的初始化、FooHolder 声明中缺少继承以及缺少 public 关键字，因为我们正在处理类。这是它的固定版本。
#include <iostream>
#include <string>
class A {
public:
virtual const int& Foo() const = 0;
};
template <typename T>
class FooHolder : public virtual A {
public:
const int& Foo() const override { return foo_; }
static int foo_;
};
class B : public virtual A, public FooHolder<B> { };
class C : public virtual A, public FooHolder<C> { };
template<>
int FooHolder<B>::foo_(0);
template<>
int FooHolder<C>::foo_(0);
int main()
{
B b;
C c;
std::cout << b.Foo() << std::endl;
std::cout << c.Foo() << std::endl;
}
【讨论】：
唉，C++ 没有虚拟静态数据成员。有几种方法可以或多或少地模拟这一点：
我建议使用不同的基于CRTP 的解决方案，使用mix-in 类：
class A {
virtual const int& Foo() const = 0;
}
template <typename T>
class FooHolder {
static int foo_;
const int& Foo() const override { return foo_; }
}
class B : A, virtual FooHolder<B> { }
class C : B, virtual FooHolder<B> { }
在子类中你唯一需要做的就是指出混合继承。我可能在这里遗漏了一些虚拟继承注意事项（因为我很少使用它）。
请注意，您要么必须在某处实例化和初始化每个子类的静态变量，要么可以将其设为 inline 变量 (C++17) 并在模板中对其进行初始化。
这个答案改编自我对dupe question 的回答。
【讨论】：