c++ - 描述从多个接口(interface)派生的对象

Question

在 C++ 中，我有两个纯抽象类(Viewable 和 Movable)，它们可能有许多类型(Dog、Duck、Cat)从一个或两个接口(interface)派生。

我想定义一个接受单个参数的函数，其中该参数实现两个接口(interface)。据我所知，在 C++ 中，一个对象只能有一个静态类，所以我试图想出不同的方法来解决这个问题。

下面的方法 go1 有两个参数 Viewable 和 Movable。如果我有一个像 Dog 这样的派生两个接口(interface)的类型，我可以调用 go1(d, d)。但是，我想阻止 go1(d, c)，其中 c 和 d 是不同的对象(可能具有不同的类)。

我可以创建一个派生自 Movable 和 Viewable 的新类型 MovableAndViwable，但这需要我更改类的定义以派生自 MovableAndViwable，而不是派生自两个单独的接口(interface)。此外，如果我有很多接口(interface)并且想将这个想法扩展到两种以上的类型，我最终会得到很多“混合”类型(例如，MovableAndViewableAndSavableAndRunnableAndRestorable ...)

所以我的问题是:是否有 Elixir 来解决我所描述的问题。请参阅我的示例代码中的方法 go3 - 我想要一种向编译器描述对象派生自两个或多个不同且不相关的 C++ 类的方法。

此外，我对我的类的其他设计很感兴趣，现在想知道除 C++ 之外的其他语言如何解决这个问题(假设我不需要使用 C++)。

#include <iostream>

struct Movable { virtual void move() const = 0; };
struct Viewable { virtual void view() const = 0; };
struct MovableAndViewable : Movable, Viewable {};

struct Dog : virtual Movable, virtual Viewable {
    void move() const { std::cout << "Moving\n"; }
    void view() const { std::cout << "Viewing\n"; }
};
struct Duck : virtual Movable, virtual Viewable {
    void move() const { std::cout << "Moving\n"; }
    void view() const { std::cout << "Viewing\n"; }
};
struct Cat : virtual MovableAndViewable {
    void move() const { std::cout << "Moving\n"; }
    void view() const { std::cout << "Viewing\n"; }
};
struct Fish : virtual Movable {
    void move() const { std::cout << "Moving\n"; }
};

void go1(Movable const &m, Viewable const &v) { m.move(); v.view(); }
void go2(MovableAndViewable const &mv) { mv.move(); mv.view(); }
//void go3(Movable and Viewable const &mv) { mv.move(); mv.view(); }

int main()
{
    Dog d;
    Cat c;
    Fish f;

    go1(d, d);
    //go1(f, f); // Nope, Fish isn't Viewable
    //go2(d);
    go1(c, c);
    go2(c);
    //go3(d);
    //go3(c);
    return 0;
}

Answer 1

下面的方法怎么样。它似乎满足您传递单个参数的预期目标:

class Movable {
public:
    virtual void move()=0;
};

class Viewable {
public:
    virtual void view()=0;
};

// A stub class, used for parameter passing.

class MovableAndViewable {

public:
    Movable &m;
    Viewable &v;

public:
    template<typename m_and_v> MovableAndViewable(m_and_v &object)
        : m(object), v(object)
    {
    }
};

// Passing only a single parameter:    
void go2(const MovableAndViewable &mv)
{
    mv.m.move();
    mv.v.view();
}

// Example:

class MV : public Movable, public Viewable {

public:

    void move()
    {
    }

    void view()
    {
    }
};

void go3()
{
    MV mv;

    go2(mv);
}

那么，另外我还要声明:

class const_MovableAndViewable {

public:
    const Movable &m;
    const Viewable &v;

public:
    template<typename m_and_v> const_MovableAndViewable(const m_and_v &object)
        : m(object), v(object)
    {
    }
};

// In order to be able to pass references to const objects:

void const_go2(const const_MovableAndViewable &mv);