Question

我有一个基类，

class Msg
{
   public:

     ParseMsg()
     {
         ParseMsgData();
         ParseTrailer();
     }
     virtual void ParseMsgData() = 0;
     ParseTrailer();

};

和派生类，

class InitiateMsg : public Msg
{
    public:
    void ParseMsgData() { ... }
};


class ReadOperationMsg  public Msg
{
   public:
    void ParseMsgData() { ... }
};


class WriteOperationMsg  public Msg
{ 
   public:

    void ParseMsgData() { ... }
};

，方案如下，

    void UsageFunction(string data)
    {
      Msg* msg = ParseHeader(data);
      ParseMsg
    }

   Msg* ParseHeader(string data)
   {

        Msg *msg = NULL;
           ....
         switch() 
         {

            case 1: 

                 msg = new InitiateMsg();
                 break;
            case 2:
                 msg = new ReadOperationMsg{();
                 break;
             case 3:
                 msg = new WriteOperationMsg{();
                 break;
               ....

         }

          return msg;           
    }

基于数据ParseHeader方法将决定必须创建哪个对象，所以我在我正在使用的类之外实现了ParseHeader函数。如何在Msg类中创建ParseHeader函数然后使用它？

在C＃中，通过在类中将ParseHeader方法定义为静态并从外部使用它来实现相同的目的，

Answer 1

您需要 Abstract Factory 设计模式。它是为您的场景定制的。
内联链接更详细地解释了一个简单的例子，而不是我在这里。

Answer 2

好吧，在任何有用的注释之前，你忘记将它们声明为public并忘记在类定义中声明继承关系。

对于您的问题，为什么不直接将ParseHeader函数声明为基类Msg的公共成员方法。如果你这样做，我看不出任何问题。

可能存在一些依赖性问题。您需要将该方法作为声明放在Msg中，并在cpp文件中定义主体。类似的东西：

// in Msg.h
// all other lines are omitted
public:
  Msg* ParseHeader(string data);


// in Msg.cpp
#include "Msg.h"
#include "InitiateMsg.h"
#include "ReadOperationMsg.h"
#include "WriteOperationMsg.h"

Msg* Msg::ParseHeader(string data) {
// .....
}

另外，如果你想区分具有基指针的确切类别。如果我这样做，我将在基类中声明一个emun来记住它。类似的东西：

// Msg.h
class Msg{
public:
    enum type_t {
      TBase,
      TInit,
      TRead,
      TWrite
    } type;

然后在每种不同的构造方法中，为类型变量定义不同的type_t。因此，您始终可以告诉指针指向哪个类，并进行动态类转换而不会错过试用。

C ++动态对象构造

2 个答案: