抽象类中可以有静态数据成员吗？

Question

我设计了一系列相关的类，为了能够管理它们，我让它们从一个抽象类派生。

这些类都需要访问一系列共享资源，我发现自己在每个类中创建了一个指针向量，它们全部相同（它们必然必须相同）。似乎在基类中创建一个静态成员将使所有派生类都可以访问该向量，这意味着我只需要构建它一次（构建后它也不会改变，只需查找）。

我的问题是这是否可以，如果可以，我如何构建它，而不从派生类之一调用“填充向量”方法？

我的想法是做类似的事情

class Resource {};

enumR {RES0, RES1};

class AbstractClass
{
    public:
        virtual void OnInit() = 0;
        void static fillVector(Resource* pResource, enumR Resourcename)
            {lResource[Resourcename]=pResource;};
    protected:
        static vector<Resource*> lResource;
};

vector<Resource*> AbstractClass::lResource;

int main()
{
    Resource res0, res1;
    AbstractClass::fillVector(&res0, RES0);
    AbstractClass::fillVector(&res1, RES1);

    return 0;
};

然后当我实例化从 AbstractClass 派生的任何类的对象时，我可以访问 lResource 向量，这就是我想要的。

这行得通吗？可怕吗？可以吗？

Answer 1

它会起作用，其中工作=编译&跑步。

但是，所有子类都将访问相同的静态向量，这意味着每个子类不会有不同的静态向量副本。

为了更好地解释我的意思，请阅读以下主题：

静态字段是否继承？

解决方案：

一种解决方案是为您的父类提供一个模板类，如下所示：

template<T>
class Parent<T> {
    public:
        static std::vector<T> sharedResource_;
}

class ChildA : Parent<ChildA> {
}

class ChildB : Parent<ChildB> {
}

在上面的代码中，您将获得 ChildA 的所有实例的共享资源，以及在实例<之间共享的另一个资源。 /em> 的儿童 B.

是吗？

嗯，我认为这不算好。与此相关的讨论之一是对以下 SO 问题的评论以及我对该问题的回答：

如何执行“静态重载” C# 中的 const？

Answer 2

更好的解决方案是只创建一个带有向量的对象，然后仅实例化它一次，并为其他类提供指向它的指针或引用。除非必要，否则绝对应该避免使用静态数据，而这并不是必要的。

Answer 3

您可以添加静态函数来初始化静态向量：

class AbstractClass
{
    private:
        // Add this
        static vector<Resource*> CreateResources();

    protected:
        static vector<Resource*> lResource;
};

vector<Resource*> AbstractClass::lResource = CreateResources();

vector<Resource*> AbstractClass::CreateResources()
{
    vector<Resource*> resources;

    resources[RES0] = new Resource();
    resources[RES1] = new Resource();

    return resources;
}

Answer 4

您可以尝试 boost::assign::list_of ，如下所示：

vector<Resource*> AbstractClass::lResource = list_of( &res0 )( &res1 );

Answer 5

我在这里有几点。

• 您的向量的大小可能为 0。这可能会导致一些崩溃。您必须在使用之前分配它。您可以进行静态或全局初始化。
• 你真的想要一个向量吗？当您使用某些动态内存分配时，向量是合适的。枚举是静态的。您可以给出一个简单的计数并将其分配为数组。
• 你真的想要一个静态成员吗​​？静态成员通常在同一类的对象之间共享时使用。您可以使用类中本地/全局的外部对象来满足要求吗？您还可以在类中创建静态函数吗？

Answer 6

由于您正在创建“资源指针”向量并且没有提前为对象保留空间，因此您的系统将来可能会崩溃。为什么？
当您插入元素时，Vector 会创建一个内存块，并使用同一块，直到达到其容量为止。一旦达到其容量并且插入一个新元素，向量将分配一个新内存（是先前分配的内存的两倍）并将所有现有元素复制到新内存中。由于这是一个“指针”向量，因此它将使所有引用无效。

Answer 7

在这些情况下，我通常做的是添加一个中间模板化层，这样我就有了这样的结构：

定义抽象接口：

class A
{
public:
virtual ~A(){}

virtual void f() = 0 

virtual A* Clone() const = 0
}

将子级常用的资源放入模板中，并在必要时使用 CRTP 定义样板函数，保留必要的接口函数仍然是抽象的

template<class Derived>
class A_T: public A
{
public:
virtual void f() = 0;

virtual A* Clone const
{
return new Derived(dyn_cast<Derived&>(*this))
}

void ManageRes();

private:
vector myResource;
}

最后，不同的具体类完成实现，并在必要时对这些资源做一些特殊的事情

class Child: public A_T<Child>
{
public: 
void foo();
}