c++ - dynamic_cast 的用例

Question

在很多地方你可以读到 dynamic_cast 意味着“糟糕的设计”。但是我找不到任何具有适当用法的文章(展示了良好的设计，而不仅仅是“如何使用”)。

我正在编写一个棋盘游戏，其中包含一个棋盘和描述了许多属性的许多不同类型的卡片(有些卡片可以放在棋盘上)。所以我决定将其分解为以下类/接口(interface):

class Card {};
class BoardCard : public Card {};
class ActionCard : public Card {};
// Other types of cards - but two are enough
class Deck {
    Card* draw_card();
};
class Player {
    void add_card(Card* card);
    Card const* get_card();
};
class Board {
    void put_card(BoardCard const*);
};

有些人建议我应该只使用一个类来描述一张卡片。但我的意思是许多相互排斥的属性。对于 Board 类的 put_card(BoardCard const&) - 这是接口(interface)的一部分，我不能在板上放置任何卡。如果我只有一种类型的卡，我将不得不在方法中检查它。

我看到的流程如下:

• 一张通用牌在牌组中(它的类型并不重要)
• 从牌组中抽取一张通用牌并交给玩家(同上)
• 如果玩家选择了BoardCard，则可以将其放在板上

所以我使用 dynamic_cast 之前将卡片放在板上。我认为在这种情况下使用一些虚拟方法是不可能的(另外，我不会在每张卡片上添加一些关于棋盘的 Action )。

所以我的问题是:我设计的不好？我怎样才能避免 dynamic_cast？使用一些类型属性和 ifs 会是更好的解决方案...？

附:任何在设计环境中处理 dynamic_cast 用法的来源都非常感谢。

Answer 1

是的，dynamic_cast 是一种代码味道，但是添加一些函数也是如此即像 can_put_on_board 这样的东西。我什至会说 can_put_on_board 更糟糕 - 你正在复制由 dynamic_cast 实现的代码并弄乱界面。

与所有代码异味一样，它们应该让您保持警惕，它们并不一定意味着您的代码不好。这一切都取决于您要达到的目标。

如果您正在实现一个包含 5k 行代码、两类卡片的棋盘游戏，那么任何可行的方法都可以。如果您正在设计更大、可扩展的东西，并且可能允许非程序员创建卡片(无论是实际需要还是您正在研究)，那么这可能行不通。

假设是后者，让我们看看一些替代方案。

您可以将正确应用卡的责任放在卡上，而不是一些外部代码。例如。向卡片添加一个 play(Context& c) 函数(Context 是访问棋盘的一种手段，以及可能需要的任何东西)。棋盘卡会知道它只能应用于棋盘并且不需要类型转换。

但是，我会完全放弃使用继承。它的众多问题之一是它如何引入所有卡片的分类。举个例子吧:

• 你介绍BoardCard和ActionCard把所有卡片放在这两个桶里；
• 然后您决定想要一张可以以两种方式使用的卡片，作为 Action 或 Board 卡片；
• 假设您解决了问题(通过多重继承、BoardActionCard 类型或任何其他方式)；
• 然后你决定你想要卡牌颜色(就像在 MtG 中一样)——你是怎么做到的？您是否创建 RedBoardCard、BlueBoardCard、RedActionCard 等？

为什么应该避免继承以及如何实现运行时多态性的其他示例，否则您可能想观看 Sean Parent 的优秀 "Inheritance is the Base Class of Evil" talk .实现这种多态性的有前途的库是dyno。 ，不过我还没试过。

一个可能的解决方案可能是:

class Card final {
public:
    template <class T>
    Card(T model) :
        model_(std::make_shared<Model<T>>(std::move(model)))
    {}

    void play(Context& c) const {
        model_->play(c);
    }

    // ... any other functions that can be performed on a card

private:

    class Context {
    public:
        virtual ~Context() = default;
        virtual void play(Context& c) const = 0;
    };

    template <class T>
    class Model : public Context {
    public:
        void play(Context& c) const override {
            play(model_, c);

            // or

            model_.play(c);

            // depending on what contract you want to have with implementers
        }
    private:
        T model_;
    };

    std::shared_ptr<const Context> model_;

};

然后您可以为每种卡片类型创建类:

class Goblin final {
    void play(Context& c) const {
        // apply effects of card, e.g. take c.board() and put the card there
    }
};

或实现不同类别的行为，例如有一个

template <class T>
void play(const T& card, Context& c);

模板，然后使用 enable_if 来处理不同的类别:

template <class T, class = std::enable_if<IsBoardCard_v<T>>
void play(const T& card, Context& c) {
    c.board().add(Card(card));
}

地点:

template <class T>
struct IsBoardCard {
    static constexpr auto value = T::IS_BOARD_CARD;
};

template <class T>
using IsBoardCard_v = IsBoardCard<T>::value;

然后将您的 Goblin 定义为:

class Goblin final {
public:
    static constexpr auto IS_BOARD_CARD = true;
    static constexpr auto COLOR = Color::RED;
    static constexpr auto SUPERMAGIC = true;
};

这将允许您在多个维度上对您的卡片进行分类，还可以通过实现不同的 play 函数来完全专门化行为。

示例代码使用 std::shared_ptr 来存储模型，但您绝对可以在这里做一些更聪明的事情。我喜欢使用静态大小的存储，并且只允许使用某个最大大小和对齐的 T。或者，您可以使用 std::unique_ptr (虽然会禁用复制)或利用小尺寸优化的变体。