Question

A类使用以下两个函数构建和发送消息1＆amp; 2

builder::prepareAndDeliverMsg1(msg1_arg1,msg1_arg2)
{
}

builder::prepareAndDeliverMsg2(msg2_arg1,msg2_arg2)
{
}

现在，引入了一个新的B类，它希望在两个阶段完成A的工作

stage1-＆GT;准备 stage2-＆GT;递送

我正在考虑扩展构建器类，如下所示：

///----

builder::prepareMsg1(msg1_arg1,msg1_arg2)
{
}

builder::prepareMsg2(msg2_arg1,msg2_arg2)
{
}

builder::deliverMsg1(msg1_arg1)
{
    This function, inserts re-calculated msg1_arg1 into the prepared message in stage1
}

builder::deliverMsg2(msg2_arg1)
{
   This function, inserts re-calculated msg2_arg1 into the prepared message in stage1
}

// These two functions are still retained for the usage of class A
builder::prepareAndDeliverMsg1(msg1_arg1,msg1_arg2)
{
}

builder::prepareAndDeliverMsg2(msg2_arg1,msg2_arg2)
{
}

//---

我想知道，如果有更好的设计方法吗？

Answer 1

也许对于每条消息，创建自己的类并从基类消息类继承？

class TBaseMsg
{
public:
   virtual void prepare() = 0;
   virtual void deliver() = 0;
}

Answer 2

你可以看一下Decorator的设计模式。

http://en.wikipedia.org/wiki/Decorator_pattern

Answer 3

您的解决方案对我来说没问题。

Answer 4

要扩展Darks的想法，您可以拥有一个实现组合准备的基类，并根据单独的函数提供，并允许派生类根据需要覆盖这些类：

class base {
    virtual bool prepareMsg1() = 0;
    virtual bool prepareMsg2() = 0;
    virtual bool deliverMsg1() = 0;
    virtual bool deliverMsg2() = 0;
    bool prepareAndDeliverMsg1(){
        prepareMsg1();
        deliverMsg1();
    }
    bool prepareAndDeliverMsg2(msg2_arg1,msg2_arg2){
        prepareMsg2();
        deliverMsg2();
    }
};

您可能会发现两个派生类中的许多功能都是相同的，在这种情况下您不希望在基类中使用纯虚拟机：

class base {
    virtual bool prepareMsg1(args) {//not pure virtual
        //do the common stuff
    }
};

class derived {
    bool prepareMsg1( args ) {
        base::prepareMsg1(args);
        //code to specailise the message
    }
};

甚至可能是基类包含原始类，但允许派生第二个类而不必重复使用公共代码。

有没有更好的方法来设计此消息传递代码？

4 个答案: