c++是一种基于组件的体系结构，通过继承实现，被认为是良好的实践

C++ Is a components-based architeture implemented via inheritance considered good practice?

本文关键字：实现 继承 认为是 一种 于组件 体系结构 c++ 组件      更新时间：2023-10-16

我正在实现一个架构，当我有一个异构对象的容器，可能有或没有一些共同的方法属性。我需要循环遍历它们，应用一些函数，更新一些成员，并在不同的接口上调用一些方法。

我认为这是一个基于继承的"标准"架构:

#include <vector>
#include <memory>
#include <iostream>
using namespace std;
struct Base {
    virtual ~Base() {}
};
struct PositionInterface {
    int x = 0;
    int y = 0;
    virtual ~PositionInterface() {}
};
struct DrawInterface {
    void draw() { cout << "Here i am" << endl; }
    virtual ~DrawInterface() {}
};
struct ChargeInterface {
    int charge = 100;
    virtual ~ChargeInterface() {}
};
struct LifeInterface {
    int life = 100;
    virtual ~LifeInterface() {}
};
struct A: public Base,
          public LifeInterface, public PositionInterface {};
struct B: public Base,
          public DrawInterface, public PositionInterface, public ChargeInterface {};
int main() {
    std::vector<std::shared_ptr<Base>> vec;
    vec.push_back(make_shared<A>());
    vec.push_back(make_shared<B>());
    for (auto & el : vec) {
        auto p = dynamic_cast<PositionInterface *>(el.get());
        if (p) {
            p->x += 10;
            p->y -= 10;
        }
    }
    // ..other stuff
    for (auto & el : vec) {
        auto l = dynamic_cast<LifeInterface *>(el.get());
        if (l) {
            l->life -= 100;
        }
    }
    // ..other stuff
    for (auto & el : vec) {
        auto d = dynamic_cast<DrawInterface *>(el.get());
        if (d) {
            d->draw();
        }
    }
}

无论如何，我所看到的看起来也像一个基于组件的系统。在我看来，这些接口可能是通过组合而不是继承添加的组件。像这样:

struct A: public Base {
    LifeInterface l;
    PositionInterface p;
};

但是，我如何通过Base对象的向量dynamic_cast循环到正确的接口呢?

您认为这种体系结构有什么缺点吗(除了RTTI和公共变量:-))?

"但是，我如何循环通过基本对象的向量dynamic_casting到正确的接口?"

我建议使用真实的抽象接口，像这样: 
struct Base {
    virtual ~Base() {}
};
struct PositionInterface {
    virtual int x() const = 0;
    virtual void x(int value) = 0;
    virtual int y() const = 0;
    virtual void y(int value) = 0;
    virtual ~PositionInterface() {}
};
struct DrawInterface {
    virtual void draw() const = 0;
    virtual ~DrawInterface() {}
};
struct ChargeInterface {
    virtual int charge() const = 0;
    virtual ~ChargeInterface() {}
};
struct LifeInterface {
    virtual int life() const {};
    virtual ~LifeInterface() {}
};

可以用作mixins的基实现类

class PositionBase : public PositionInterface {
public:
    virtual int x() const { return x_; }
    virtual void x(int value) { x_ = value; }
    virtual int y() const { return y_; }
    virtual void y(int value) { y_ = value; }
    virtual ~PositionBase() {}
protected:
    PositionBase() {}
    int x_;
    int y_;
};
class ChargeBase : public ChargeInterface {
public:
    virtual int charge() const { return charge_; }
    virtual ~ChargeInterface() {}
protected:
    ChargeBase(int charge) : charge_(charge) {}
    const int charge_;
};
class LifeBase : public LifeInterface {
public:
    virtual int life() const { return life_; }
    virtual ~LifeBase() {}
protected:
    LifeBase(int life) : life_(life) {}
    const int life_;
};

让你的实现像下面这样

struct A 
: public virtual Base
, public LifeBase
, public PositionBase {
    A() : Base(), LifeBase(100), PositionBase() {}
};
struct B 
: public virtual Base
, public DrawInterface
, public PositionBase
, public ChargeBase {
    B() : Base(), PositionBase(), ChargeBase(100)
    virtual void draw() const {
        // Must implement draw()
    }
};
    不要使用公共成员变量，因为你不能从继承的类中控制这些变量。如上所示使用虚拟getter/setter函数。
  1. 使用dynamic_cast<>查看是否支持正确的接口。要对这些文件执行操作，可以提供简单的模板化函数，例如:
template<class T> void draw(const T& item) {
    DrawInterface* drawableItem = dyn<mic_cast<DrawInterface*>(&item);
    if(drawableItem) {
        drawableItem->draw();
    }
    // Item isn't drawable, ignore or throw exception
}

RTTI的主要缺点是使用它，所以使它不可能是一件好事。

使用可能为空的指针、接口指针返回函数或类似boost::optional的类型。

的例子:

class Base
{
public:
    virtual LifeInterface* life() { return 0; }
    virtual PositionInterface* position() { return 0; }
};
class A: public Base {
public:
    LifeInterface* life() { return &l; }
private:
    LifeInterface l;
};
// ...
for (auto & el : vec) {
    auto l = el.life();
    if (l) {
        l->life -= 100;
    }
}

相关文章：