C++ - 通过单个指针访问多个对象的接口(interface)

Question

我需要存储一个对象指针容器。这些对象有一些我想要强制执行(可能在编译时)和使用的通用方法/属性(接口(interface))。示例:

struct A{
    void fly(){}
};

struct B{
    void fly(){}
};

A a;
B b;
std::vector<some *> objects;
objects.push_back(&a);
objects.push_back(&b);

for(auto & el: objects)
    el->fly();

更简单的解决方案是 A 和 B 继承一个共同的基类，如 FlyingClass:

struct FlyingClass{
    void fly(){}
};
struct A: public FlyingClass { ...
struct B: public FlyingClass { ...

并创建一个

std::vector<FlyingClass *> objects;

这将起作用并强制执行这样一个事实，即我只能向 objects 添加可以飞行的东西(实现 FlyingClass)。

但是，如果我需要实现一些其他常用方法/属性而不将它们与上述基类耦合怎么办？

例子:

struct A{
    void fly(){}
    void swim(){}
};

struct B{
    void fly(){}
    void swim(){}
};

我想做的是:

for(auto & el: objects) {
    el->fly();
    ...
    el->swim();
    ...
}

更一般地说，我将能够调用传递这些指针之一的函数并访问两个常用方法/属性，例如:

void dostuff(Element * el){
    el->fly();
    el->swim();
}

我可以尝试从另一个接口(interface)继承，例如:

struct SwimmingClass{
    void swim(){}
};

struct A: public FlyingClass, public SwimmingClass { ...
struct B: public FlyingClass, public SwimmingClass { ...

但是容器应该包含什么？

std::vector<FlyingClass&&SwimmingClass *> objects;

当然，我可以实现 SwimmingFlyingClass，但是如果我需要 RunningClass 等怎么办。这将是一场噩梦。换句话说，如何在不耦合它们的情况下实现指向多个接口(interface)的指针？

或者有一些重新思考问题的模板方法？如果有一种优雅且可维护的方式来执行此操作，即使是运行时类型信息也可以在我的应用程序中接受。

Answer 1

它是可以做到这一点，以一种相当重 TMP 的方式，在运行时有点昂贵。重新设计是有利的，因此不需要这样做。总而言之，如果没有语言支持，你想做的事情是不可能干净利落的，而 C++ 不提供这种支持。

至于丑陋的，请屏蔽你的眼睛:

struct AnyBase { virtual ~AnyBase() {} }; // All derived classes inherit from.
template<typename... T> class Limited {
    AnyBase* object;
    template<typename U> Limited(U* p) {
        static_assert(all<is_base_of<T, U>...>::value, "Must derive from all of the interfaces.");
        object = p;
    }        
    template<typename U> U* get() {
        static_assert(any<is_same<U, T>...>::value, "U must be one of the interfaces.");
        return dynamic_cast<U*>(object);
    }
}

其中一些内容未定义为标准，因此我将简单介绍一下。构造函数上的 static_assert 强制 U 继承自所有 T。我可能把 U 和 T 弄错了，all 的定义留给读者。

getter 只需要 U 是模板参数之一 T...。然后我们提前知道 dynamic_cast 会成功，因为我们静态地检查了约束。

它很丑陋，但它应该可以工作。所以考虑

std::vector<Limited<Flying, Swimming>> objects;
for(auto&& obj : objects) {
    obj.get<Flying>()->fly();
    obj.get<Swimming>()->swim();
}