避免嵌入式目标上的虚拟函数

我有一个class Player从由许多相等的块组成的大内存块中回放数据。

typedef char chunk_t[100];

typedef struct {
    chunk_t data[100]
} blockOfMemory_t;

理论上，播放器本身可以适用于不同的布局和数据内容，因此我想以可重用的方式对其进行编程。为此，我想到了这样的事情：

class Player {
public:
    Player() { ... }
    virtual ~Player() { ... }

    void play() 
    {
        for (int i = 0; i < getNumChunks(); i++)
        {
           if (chunkHasX(i) || chunkHasY(i))
               playChunk(i);
        }
    }

protected:
    virtual int getNumChunks() = 0;
    virtual bool chunkHasX(int chunkIndex) = 0;
    virtual bool chunkHasY(int chunkIndex) = 0;
    virtual void playChunk(int chunkIndex) = 0;
}

通过继承它并在子级中实现数据细节，我可以实现可重用性。

然而，目标是 ARM Cortex-M4 处理器，速度非常重要。因此，我预计使用虚拟函数时会出现性能缺陷。因此，我正在寻找一种方法来实现相同类型的可重用性，该方法可以在编译时解决，并且允许内联chunkHasX(..), etc.

这是尖叫的“模板” - 但我该怎么做呢？

谢谢你！

我假设您已经测量并确认了虚拟函数调用的成本或增加的对象大小使得这样做是可取的。或者您可能只是认为模板设计更好。

通过 CRTP 进行继承

如果你想使用继承，你可以使用奇怪的重复模板模式（CRTP） https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern。您有一个模板化的 Player 基类，其中模板参数是派生类：

template<class Derived>
class Player {
public:
    void play() 
    {
        auto& derived = static_cast<Derived&>(*this);
        
        for (int i = 0; i < derived.getNumChunks(); i++)
        {
           if (derived.chunkHasX(i) || derived.chunkHasY(i))
               derived.playChunk(i);
        }
    }
};

class DerivedPlayer : public Player<DerivedPlayer> {
private:
  friend class Player<DerivedPlayer>;
  int getNumChunks();
  bool chunkHasX(int chunkIndex);
  bool chunkHasY(int chunkIndex);
  void playChunk(int chunkIndex);
};

int main() {
    DerivedPlayer p;
    p.play();
}

现场演示 https://wandbox.org/permlink/kVh9KJ5dUR8m2C4d.

作品

或者也许您可以使用组合而不是继承并组合您的Player of a ChunkHolder它作为模板参数传递：

template<class ChunkHolder>
class Player {
private:
    ChunkHolder chunk_holder;
public:
    void play() 
    {   
        for (int i = 0; i < chunk_holder.getNumChunks(); i++)
        {
           if (chunk_holder.chunkHasX(i) || chunk_holder.chunkHasY(i))
               chunk_holder.playChunk(i);
        }
    }
};

class MyChunkHolder {
public:
  int getNumChunks();
  bool chunkHasX(int chunkIndex);
  bool chunkHasY(int chunkIndex);
  void playChunk(int chunkIndex);
};

int main() {
    Player<MyChunkHolder> p;
    p.play();
}

现场演示 https://wandbox.org/permlink/G4sDxRCrw9KCmCyU.

Update:Russ Schultz 的评论提醒我，如果你想多态地对待这些不同的玩家，你可以。简单介绍一个接口：

class IPlayer {
public:
  virtual ~IPlayer(){}
  virtual void play() = 0;
};

然后在这两种情况下你都可以继承这个接口并覆盖play()功能：

template<class T>
class Player : IPlayer {
public:
    void play() override;
};

例如，现在您可以将玩家放入一个容器中，但不会通过在内部循环中调用虚拟函数来影响性能。 现场演示CRTP https://wandbox.org/permlink/bD9p0aOUIJmXRK3Z and 作品 https://wandbox.org/permlink/3Hdg1PPTqAQiFqqa.