Question

我很遗憾这个标题非常讨厌，很难解释

class BaseState {
protected:
    BaseState();
public:
    void Some();
    void Useful();
    void Methods();
};

class UsefulState: public BaseState {
public:
    void moreUsefulStuff();
};

class SomeUsefulBase {
protected:
    SomeUsefulBase(BaseState* pState) { state = pState; }
    void UsefulMethods() { state->Some(); }
    void Andthings() { state->Useful(); }
public:
    virtual void doSomething() = 0;
protected:
    BaseState* state;
};

class SomethingUseful: public SomeUsefulBase {
public:
    SomethingUseful(UsefulState* pState): SomeUsefulBase(pState) {
        usefulState = pState;
    }
    virtual void doSomething() { usefulState->moreUsefulStuff();} 
protected:
    UsefulState* usefulState;
};

然后：

SomethingUseful whatever(new UsefulState());

在分配内容的地方并不重要，但是会有很多来自SomethingUseful的类将使用UsefulState，但是SomeUsefulBase的所有成员函数都将使用该状态，但作为BaseState

我希望有一种比使用两个成员（定义中的UsefulState和BaseState指针）更好的方法，我想到了一个联合和一个模板，但那会很难看。

我也不想乱丢我的代码，我想知道是否有更好的符号。

每个操作将有一个UsefulState，并且将由SomethingUseful的各个子类和/或SomethingUsefulBase的子类形成一个大的树结构，其中UsefulState指针是期待。

附录：不确定SO的语法突出显示了什么！它似乎是使用案例来决定是否要将颜色变成蓝色......不确定它是如何工作的。

附录2：在使用中，这个例子来源于每个操作有一个状态，但很多东西都是从SomeUsefulBase派生的，派生类会相互创建形成一个大的树结构（上帝我听起来很无声），但都需要使用衍生国家。

Answer 1

这听起来像标准的“抽象工厂”式的情况：

struct AbstractGadget { virtual ~AbstractGadget() {} };
struct AbstractWidget { virtual ~AbstractWidget() {} };
struct AbstractThingy { virtual ~AbstractThingy() {} };

struct AbstractFactory
{
    virtual ~AbstractFactory() {}

    virtual std::unique_ptr<AbstractGadget> make_gadget() = 0;
    virtual std::unique_ptr<AbstractGadget> make_widget() = 0;
    virtual std::unique_ptr<AbstractGadget> make_thingy() = 0;
};

用法：

struct Gadget1 : AbstractGadget { /* ... */ };
struct Widget1 : AbstractWidget { /* ... */ };
struct Thingy1 : AbstractThingy { /* ... */ };

struct Factory1 : AbstractFactory
{
    virtual std::unique_ptr<AbstractGadget> make_gadget()
    {
        return { new Gadget1; }
    }

    // ...
};

Factory2和Widget3等等。此处也有很多用模板消除样板代码的潜力。

可能会向消费者提供AbstractFactory & f并致电f.make_gadget()等来创建合适类型的对象。

C ++，一些类派生自一个类，所有派生类都使用从其他东西派生的类，但它们的基础使用了该clase的基础

1 个答案: