多态性 - 正确使用指向纯抽象类的指针?

发布于 2024-12-17 06:40:36 字数 703 浏览 0 评论 0 原文

我正在使用 OpenGL(加上 GLUT 和 GLUI)实现一个简单的棋盘游戏(突破)。

我正在考虑实现一个 Board 类,它将有一个 vector 。 > 作为其属性之一。 Cell 代表游戏板中的一个空间。它可以包含一个GameObjectGameObject 将是一个纯抽象类。例如,它要求其派生类实现 render() 。可能的派生类将是:

  • Blank,代表一个空的空间
  • Pawn,代表一个棋子(Breakthrough 中唯一可能的棋子)

棋盘将通过首先渲染棋盘来渲染,然后迭代每个Cell,获取其内容并为每个单元调用render()

我能想到的实现此目的的唯一可能方法是将 Cell 中的 GameObject 设为指针 (board[y][x].getContents()-> ;render(),其中 getContents() 返回 GameObject*

这是执行此操作的最佳方法吗?这是指针的正确用法吗?

I am implementing a simple board game (Breakthrough) using OpenGL (plus GLUT and GLUI).

I'm thinking of implementing a Board class, which will have a vector<vector<Cell> > as one of its attributes. Cell represents a space in the game board. It can contain a GameObject. GameObject will be a pure abstract class. It mandates that its derivative classes implement render(), for example. Possible derivative classes will be:

  • Blank, representing an empty space
  • Pawn, representing a pawn (the only possible pieces in Breakthrough)

The board will be rendered by first rendering the board, then iterating through each Cell, getting its contents and calling render() for each of them.

The only possible way I can think of to achieving this is making the GameObject in Cell a pointer (board[y][x].getContents()->render(), where getContents() returns the GameObject*)

Is this the best way to do this? Is this an appropriate usage of pointers?

如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。

评论(2

妥活 2024-12-24 06:40:36

让我将我的评论转化为答案。这并不意味着它在任何意义上都是完整的,只是这允许我阐明一些代码示例。我原来的评论:

没关系,尽管您可能会使用 std::unique_ptrstd::shared_ptr 做得更好,这样您就不会得到迷失在手动生命周期管理问题中。最后,大步访问平面一维数组怎么样?

我可能会这样做:

#include <vector>
#include <memory>

struct GameObject { virtual void render() const = 0; virtual ~GameObject() { } };

class Cell
{
  std::unique_ptr<GameObject> m_go;

public:
  void render() const { m_go->render(); }
  Cell() : m_go(new BlankCell) { }
  // more functions to reassign the cell value etc.
};

class Board
{
  std::vector<Cell> m_board;
  std::size_t       m_length;

public:
  Board(std::size_t length) : m_board(length * length), m_length(length) { }
  Cell & cell(std::size_t i, std::size_t j) { return m_board(j + i * m_length); }
  Cell const & cell(std::size_t i, std::size_t j) const { return const_cast<Board*>(this)->cell(i, j); }
  // more...
}

Let me promote my comment into an answer. This doesn't mean that it's in any sense complete, only that this allows me to spell out some code examples. My original comment:

That's OK, though you probably would do better with a std::unique_ptr<GameObject> or a std::shared_ptr<GameObject> so you don't get lost amids the manual lifetime management issues. Finally, how about a flat 1-D array accessible in strides?

Here's how I might go about this:

#include <vector>
#include <memory>

struct GameObject { virtual void render() const = 0; virtual ~GameObject() { } };

class Cell
{
  std::unique_ptr<GameObject> m_go;

public:
  void render() const { m_go->render(); }
  Cell() : m_go(new BlankCell) { }
  // more functions to reassign the cell value etc.
};

class Board
{
  std::vector<Cell> m_board;
  std::size_t       m_length;

public:
  Board(std::size_t length) : m_board(length * length), m_length(length) { }
  Cell & cell(std::size_t i, std::size_t j) { return m_board(j + i * m_length); }
  Cell const & cell(std::size_t i, std::size_t j) const { return const_cast<Board*>(this)->cell(i, j); }
  // more...
}
自由范儿 2024-12-24 06:40:36

是的。

另外,也许你应该为你的细胞使用另一个容器(某种矩阵等)

Yes.

Also, maybe you should use another container for your cells (some kind of matrices or so)

~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文