Question

我有一类Enemy，我想成为所有敌人类型的基类，也是纯粹的抽象类。此时，派生类应共享其所有成员和方法。特别是，方法loadTexture使用静态成员texture。

    class Enemy
    {
        int hp;
        int damage;
        //
        // all other fields
        //
        static TextureClass* texture; //needs to be static because every instance
                                      //of enemy uses the same texture
    public:
        static void loadTexture()
        {
            CreateTextureFromFile("somefilepath",&texture); //needs to be static
          // because textures are loaded before any instance is crated
        }
        void draw()
        {
            DrawToScreen(&texture, ...many data members passed here...);
        }
    };

    TextureClass* Enemy::texture = nullptr;

现在，如果我想制作Enemy摘要并创建不同的敌人类型，那么明显的选择就是继承。所以我创造了：

class EnemyA : Enemy
{
    static TextureClass* texture;
};

class EnemyB : Enemy
{
    static TextureClass* texture;
};

但是现在，我如何为每个加载纹理？我显然不能在基数中定义loadTexture。所以除了写X次相同的方法（其中X是敌人类型的数量）之外，唯一的选择是从基数中移除loadTexture并创建一个全局函数，对吗？同样适用于draw，我需要为每个派生重新定义它，即使它看起来完全一样......

TL; DR无论敌人类型如何，loadTexture和draw都具有完全相同的身体，但是他们使用每个不同的静态字段。有没有办法定义类似于统一方法的东西，在派生类中调用时会使用派生的字段，而不是基数？

感谢您的回答。

Answer 1

正如BЈовић所提到的，如果你想使用继承让loadTexture（）和draw（）方法为你的类引用正确的纹理，答案可能在于使用CRTP来实现你的Enemy类，如下：

template<typename TDerivedEnemy>
class Enemy
{
    int hp;
    int damage;
    //
    // all other fields
    //
    static TextureClass* texture; //needs to be static because every instance
                                  //of enemy uses the same texture
public:
    static void loadTexture()
    {
        CreateTextureFromFile("somefilepath",&texture); //needs to be static
      // because textures are loaded before any instance is crated
    }
    void draw()
    {
        DrawToScreen(&texture, ...many data members passed here...);
    }
};

完成后，您可以声明具体的敌人类，如下所示：

class EnemyA : public Enemy<EnemyA>
{
public:
    typedef Enemy<EnemyA> tBase;
    ...
};

class EnemyB : public Enemy<EnemyB>
{
public:
    typedef Enemy<EnemyB> tBase;
    ...
};

然后，在您的实现文件中，您还需要为EnemyA和EnemyB定义静态变量：

TextureClass* EnemyA::tBase::texture = nullptr;
TextureClass* EnemyB::tBase::texture = nullptr;

名称“Curiously Recurring Template Pattern”来自EnemyA和EnemyB从模板类继承的事实，它们已经是参数模板，因此递归。

编辑：正如评论中所讨论的，这种方法导致EnemyA和EnemyB没有共同的基类，这使得无法以统一的方式引用它们，即你不能声明例如

std::vector< EnemyA* OR EnemyB* ??? > enemies;

因为根本没有共同的基类。要解决这个问题，您可以声明一个公共抽象基类，如下所示：

class EnemyBase {
public:
    virtual void draw() = 0;
}

然后让你的模板实现从它继承：

template<typename TDerivedEnemy>
class Enemy : public EnemyBase
{
    ...
};

允许您这样做：

std::vector<EnemyBase*> enemies;

//fill the enemies vector
...

for (auto enemy : enemies)
{
    enemy->draw();
}

Answer 2

有几种方法：

使EnemyX成为一个具有静态纹理变量的模板。您甚至可以使用CRTP作为此
将纹理对象传递给敌人对象（某种IOC） - 无论是构造函数还是方法。在这种情况下，纹理不是静态的，而是指向纹理对象（指针或引用）

使用静态方法/字段继承c ++

2 个答案: