Question

晚上好，

我的任务是创建一个能够容纳游戏中所有物体的阵列。可悲的是，所有这些对象都是在不同的地方创建的 - 手动将它们放入一个数组中会很乏味 - 事实上，如果它们在物理上位于创建它们的地方我会感觉更好，但是它们存储在array ..指针形式的引用。

所以，这就是我到目前为止所知，我已经这样做了，指针将每个对象的实例添加到构造函数中的数组中，如下所示：

const int GAME_MAX_ENTS = 65536;
class Object
{
    public:
        static Object* list[GAME_MAX_ENTS];
        char type[64] = "ENT_OBJECT";
        Object();
        ~Object();
};

Object::Object()
{
    for (int i = 0; i < GAME_MAX_ENTS; i++)
    {
        if (!list[i])
        {
            list[i] = this;
            break;
        }
    }
}

Object* Object::list[GAME_MAX_ENTS];

现在，我的问题是 - 当我试图查看该列表并在与创建对象的范围不同的范围内显示'type'的值时，它会出现废话 - 我假设它是随机内存输出

这是我尝试弹出正确信息的部分：

static void OnRender()
{
    //Grid
    SDL_RenderClear(renderer);

    //Draw objects
    for (int i = 0; i < GAME_MAX_ENTS; i++)
    {
        if (Object::list[i])
        {
            Object* obj = Object::list[i];
            printf("%s\n", obj->type);
        }
    }

    [...]

..并尽可能地使一切变得清晰，这是我创建对象的部分 - 请注意，Tile只是一个继承自Object的类：

    static void Initialize()
    {
        [...]

        Tile tile;
        Object obj;
    }

我很确定这一切都归功于我缺乏使用C ++的经验，我只是一个web dev / C＃scrub - 不要狠狠地对我说谎^^

Answer 1

看起来你正在Initialize()创建对象，然后超出范围。在C ++中，您必须管理自己的内存（使用指针时）。存储指向对象的指针不会阻止它被销毁。

您需要存储对象的副本或使用new显式创建对象，然后管理指针（或使用C ++智能指针来帮助您管理它们）。

Answer 2

您应该保持指向对象的指针，使其在构造时自动添加并在销毁时删除。一种方法是使用set观察指针：

// file object.h
namespace game {
  struct object  // all game objects are derived from this
  {
    static set<const object*> const&list();  // return list of all objects
    virtual draw() const;                    // example of virtual function
    object();                                // only ctor: add this to list
    object(object const&) = delete;          // disable copy ctor of base
    virtual ~object();                       // dtor: remove this from list
  };
}

// file object.cc
#include "object.h"
#include <set>
#include <mutex>
namespace {
  std::mutex protect_object_list;
  std::set<const object*> object_list;
}

std::set<const object*> const& object::list()
{
  return object_list;
}

object::object()
{
  std::lock_guard<std::mutex> lock(protect_object_list);
  object_list.insert(this);
}

object::~object()
{
  std::lock_guard<std::mutex> lock(protect_object_list);
  object_list.erase(this);
}

用法可能看起来像

#include "object.h"
namespace game {
  struct tile : object
  {
    void draw() const override;
    tile(position const&pos) : object() { /* ... */ }
    tile(tile const&t) : object() { /* ... */ }
  };

  void draw_objects()
  {
    for(auto const&obj:object::list())
      obj.draw();
  }
}

通过这种方式，object::list中的对象按指针比较排序。如果您想要另一个排序，您可能需要使用std::map<size_t,const object*>并使用在构造对象时增加的静态计数器作为键。

指向对象的指针数组返回jibberish

2 个答案: