Question

我正在尝试找出以下问题的最佳解决方案：

我有一个管理游戏图形的库（不可直接修改）。我有一个Entity类，它是可显示实体的逻辑实体，由Sprite实例配对。

图形库已经包含管理精灵集合的支持，所以我甚至想要使用逻辑而不让逻辑知道图形引擎（我不想要包含标题）），用于与迭代实体相关的所有目的（许多实体每秒需要多次更新）。

为了在保留封装的同时获得此解决方案，我想出了一个与此类似的解决方案（我过度简化了它）：

gfx_engine.h （不可修改）

class Sprite
{
  ...
};

class SpriteBatch
{
private:
  std::vector<Sprite*> sprites;

public:
  const std::vector<Sprite*>& const getSprites() { return sprites; }
}

entity_sprite.h

#include "gfx_engine.h"

class EntitySprite : public Sprite
{
private:
  Entity *entity;

public:
  ...
  void setEntity(Entity* entity) { this->entity = entity; }
  Entity* getEntity() { return entity; }
};

entities.h

class SpriteBatch;

template<typename T>
class EntityCollection
{
private:
  SpriteBatch* batch;

public:
  class const_iterator
  {
  private:
    std::vector<Sprite*>::const_iterator inner;

  public:
    const_iterator(const std::vector<Sprite*>::const_iterator& it) : inner(it) { }

    inline bool operator!=(const const_iterator& other) const { return inner != other.inner; }
    inline const const_iterator& operator++() { ++inner; return *this; }
    T* operator*() const;
  };

  const_iterator begin() const;
  const_iterator end() const;

  EntityCollection() : batch(nullptr) { }
  explicit EntityCollection(SpriteBatch* batch) : batch(batch) { }
};

entities.cpp

#include "Entities.h"
#include "EntitySprite.h"

template<typename T> 
typename EntityCollection<T>::const_iterator EntityCollection<T>::begin() const { return const_iterator(batch->getChildren().cbegin()); }
template<typename T> 
typename EntityCollection<T>::const_iterator EntityCollection<T>::end() const { return const_iterator(batch->getChildren().cend()); }
template<typename T>
T* EntityCollection<T>::const_iterator::operator*() const { return static_cast<T*>(static_cast<EntitySprite*>(*inner)->getEntity()); }

现在，这可行（我可以做for (Entity* entity : entities)但它有两个缺点：

我被迫在EntitySprite.h中包含Entities.cpp，这应该只是一个逻辑文件（小缺点）
我需要在源文件中实现operator*()重载，以避免在EntitySprite.h中包含Entities.h（以及整个gfx引擎），但我想避免这样一个简单的函数是非内联的

问题是编译器无法内联或优化对operator*的调用（我已经检查了-O2生成的二进制文件），但是此操作每秒在数千个实体上完成60次，以获得封装我必须交易它以获得性能。

我试图避免这种情况，但我还没有找到一个好的解决方案。我想到的唯一想法是利用多重继承和reinterpret_cast，

class EntitySpriteBase
{
private:
  Entity* entity;
public:
  void setEntity(Entity* entity) { ... }
  Entity* getEntity() { ... }
}

class EntitySprite : public EntitySpriteBase, public Sprite { ... }

T* EntityCollection<T>::const_iterator::operator*() const { return static_cast<T*>(reinterpret_cast<EntitySpriteBase*>(*inner)->getEntity()); }

有什么建议吗？

Answer 1

只需将EntitySprite.h放入标题中即可完成。唯一的缺点是编译时间略长。如果编译时间对于开发很重要，那么您可以使用#ifdef NDEBUG两种方式来完成;声明中的一种方式（头文件）和实现文件中的一种方式（cpp）。

声明和定义文件之间c分隔的遗留问题是一个巨大的问题。在其他语言中，一切都始终在一个文件中，编译器/链接器为您排序（即C＃），这样就容易多了。

如何通过保持性能

1 个答案: