当我有一个异构对象的容器时,我实现了一个体系结构,它可能有或没有一些常见的方法属性。我需要遍历它们并应用一些函数,更新一些成员,并通过各种接口调用一些方法。
我已达到我认为的标准"架构,基于继承:
#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和公共变量:-))?
答案 0 :(得分:1)
“但是,我怎样才能将Base对象vector_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()
}
};
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
}
答案 1 :(得分:0)
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;
}
}