测试 c++特征类

Question

我有一组类，它们描述了一组可以容纳事物并对它们执行操作的逻辑框。我

struct IBox // all boxes do these
{
    ....
}

struct IBoxCanDoX // the power to do X
{
    void x();
}

struct IBoxCanDoY // the power to do Y
{
    void y();
}

想知道这些类的客户端处理这些可选功能的“最佳”或可能只是“最喜欢”的惯用语

a）

    if(typeid(box) == typeid(IBoxCanDoX))
    {
         IBoxCanDoX *ix = static_cast<IBoxCanDoX*>(box);
         ix->x();
    }

b）

   IBoxCanDoX *ix = dynamic_cast<IBoxCanDoX*>(box);
    if(ix)
    {
         ix->x();
    }

c）

if(box->canDoX())
{
    IBoxCanDoX *ix = static_cast<IBoxCanDoX*>(box);
    ix->x(); 
}

d）现在不同的类结构

struct IBox
{
    void x();
    void y();
}
...
box->x(); /// ignored by implementations that dont do x

e）相同除了

box->x() // 'not implemented' exception thrown

f）显式测试 功能

if(box->canDoX())
{
   box->x();
} 

我相信还有其他

。编辑：

为了使用例更清晰，

我通过交互式用户界面向最终用户公开这些内容。他们可以输入“make box do X”。我需要知道 box 是否可以做 x 。或者我需要禁用“使当前框执行X”命令

编辑2：感谢所有回答者，

正如诺亚·罗伯茨指出的（a）不起作用（解释了我的一些问题！）。 我最终做了 (b) 和一个轻微的变体

   template<class T>
    T* GetCurrentBox()
    {
       if (!current_box)
          throw "current box not set";
       T* ret = dynamic_cast<T*>(current_box);
       if(!ret)
          throw "current box doesnt support requested operation";
       return ret;
    }
    ...
    IBoxCanDoX *ix = GetCurrentBox<IBoxCanDoX>();
    ix->x();

，让 UI 管道很好地处理异常（我并不是真的抛出裸字符串）。

我也打算探索访客

Answer 1

我建议使用访客模式来解决 C++ 中的双重调度问题：

class IVisitor
{
public:
    virtual void Visit(IBoxCanDoX *pBox) = 0;
    virtual void Visit(IBoxCanDoY *pBox) = 0;
    virtual void Visit(IBox* pBox) = 0;
};

class IBox // all boxes do these
{
public:
    virtual void Accept(IVisitor *pVisitor)
    {
        pVisitor->Visit(this);
    }
};

class BoxCanDoY : public IBox
{
public:
    virtual void Accept(IVisitor *pVisitor)
    {
        pVisitor->Visit(this);
    }
};
class TestVisitor : public IVisitor
{
public:
    // override visit methods to do tests for each type.
};

void Main()
{
    BoxCanDoY y;
    TestVisitor v;
    y.Accept(&v);
}

Answer 2

在您给出的选项中，我认为 b 或 d 是“最佳”。然而，需要做大量此类事情通常表明设计很差，或者用动态类型语言而不是 C++ 可以更好地实现设计。

Answer 3

如果您使用“I”前缀来表示“接口”，就像 Java 中的含义一样，而这将通过 C++ 中的抽象基来完成，那么您的第一个选项将无法工作......所以这个选项就被淘汰了。不过我已经用它来做一些事情了。

不要做“d”，它会污染你的层次结构。保持你的界面干净，你会很高兴你这样做的。因此，Vehicle 类没有pedal() 函数，因为只有某些车辆可以踩踏。如果客户端需要pedal()函数，那么它确实需要了解那些可以实现的类。

远离“e”，原因与“d”相同，而且它违反了里氏替换原则。如果客户端需要在调用某个类之前检查该类是否响应pedal()，以便它不会爆炸，那么最好的方法是尝试转换为具有该功能的对象。 “f”与支票是一样的。

“c”是多余的。如果您按照应有的方式设置了层次结构，那么转换为 ICanDoX 就足以检查 x 是否可以执行 X()。

因此，“b”成为您从给定选项中得到的答案。然而，正如 Gladfelter 所展示的那样，您在帖子中还没有考虑到一些选项。

编辑说明：我没有注意到“c”使用的是 static_cast 而不是动态的。正如我在回答中提到的，dynamic_cast 版本更干净，应该是首选，除非特定情况另有规定。它与以下选项类似，它会污染基本接口。

编辑2：我应该注意，关于“a”，我已经使用了它，但我不像您在帖子中那样静态使用类型。每当我使用 typeid 根据类型分割流时，它总是基于运行时注册的内容。例如，打开正确的对话框来编辑某些未知类型的对象：对话框调控器根据它们编辑的类型向工厂注册。这使我在添加/删除/更改对象时不必更改任何流程控制代码。在不同情况下我通常不会使用此选项。

Answer 4

A 和 B 需要运行时类型识别 (RTTI)，如果进行大量检查，速度可能会变慢。就我个人而言，我不喜欢“canDoX”方法的解决方案，如果出现这种情况，设计可能需要升级，因为您暴露了与类不相关的信息。

如果您只需要执行 X 或 Y，具体取决于类，我会选择 IBox 中的虚拟方法，该方法会在子类中被重写。

class IBox{
   virtual void doThing();
}
class IBoxCanDoX: public IBox{
   void doThing() {  doX(); }
   void doX();
}
class IBoxCanDoY: public IBox{
   void doThing() {  doY(); }
   void doY();
}

box->doThing();

如果该解决方案不适用或者您需要更复杂的逻辑，请查看访问者设计模式。但请记住，当您定期添加新类或方法更改/添加/删除时，访问者模式不是很灵活（但这也适用于您建议的替代方案）。

Answer 5

如果您尝试从代码的偶然部分调用这些类中的任何一个操作，我建议您将该代码包装在模板函数中，并以实现鸭子类型相同的方式命名每个类的方法，因此您的客户端代码将如下所示。

template<class box>
void box_do_xory(box BOX){
    BOX.xory();
}

Answer 6

您的问题没有通用答案。一切都取决于。我只能说：
- 不要使用a)，而是使用b)
- b) 很好，需要最少的代码，不需要虚拟方法，但dynamic_cast有点慢
- c) 与 b) 类似，但速度更快（无dynamic_cast）并且需要更多内存
- e) 没有意义，你仍然需要发现是否可以调用该方法，这样就不会抛出异常
- d) 比 f) 更好（需要编写的代码更少）
- d) e) 和 f) 比其他代码产生更多垃圾代码，但速度更快且内存消耗更少

Answer 7

我假设您在这里不仅会处理一种类型的一个对象。

我会布置您正在使用的数据，并尝试了解如何将其布置在内存中，以便进行数据驱动编程。良好的内存布局应该反映您在类中存储数据的方式以及类在内存中的布局方式。一旦你有了基本的设计结构（不应该超过一张餐巾纸），我将开始根据你计划对数据执行的操作将对象组织到列表中。如果您计划对子集 X 中的对象集合 { Y } 执行 X() 操作，我可能会确保从一开始就创建一个 Y 的静态数组。如果您希望偶尔访问整个 X，可以通过将列表收集到动态指针列表中来安排（使用 std::vector 或您最喜欢的选择）。

我希望这是有道理的，但一旦实施，它就会提供简单直接的解决方案，易于理解和使用。

Answer 8

有一种通用方法可以测试一个类是否支持某个概念，然后执行最合适的代码。它使用 SFINAE hack。此示例的灵感来自 Abrahams 和 Gurtovoy 的“C++ 模板元编程”一书。如果存在，函数doIt将使用x方法，否则将使用y方法。您也可以扩展 CanDo 结构来测试其他方法。您可以根据需要测试任意多个方法，只要可以唯一解决 doIt 的重载即可。

#include <iostream>
#include <boost/config.hpp>
#include <boost/utility/enable_if.hpp>

typedef char yes;      // sizeof(yes) == 1
typedef char (&no)[2]; // sizeof(no)  == 2

template<typename T>
struct CanDo {
    template<typename U, void (U::*)()>
    struct ptr_to_mem {};

    template<typename U>
    static yes testX(ptr_to_mem<U, &U::x>*);

    template<typename U>
    static no testX(...);

    BOOST_STATIC_CONSTANT(bool, value = sizeof(testX<T>(0)) == sizeof(yes));
};

struct DoX {
    void x() { std::cout << "doing x...\n"; }
};

struct DoAnotherX {
    void x() { std::cout << "doing another x...\n"; }
};

struct DoY {
    void y() { std::cout << "doing y...\n"; }
};

struct DoAnotherY {
    void y() { std::cout << "doing another y...\n"; }
};

template <typename Action>
typename boost::enable_if<CanDo<Action> >::type
doIt(Action* a) {
    a->x();
}

template <typename Action>
typename boost::disable_if<CanDo<Action> >::type
doIt(Action* a) {
    a->y();
}

int main() {

    DoX         doX;
    DoAnotherX  doAnotherX;
    DoY         doY;
    DoAnotherY  doAnotherY;

    doIt(&doX);
    doIt(&doAnotherX);
    doIt(&doY);
    doIt(&doAnotherY);
}