返回不同类型/类的方法的设计模式

Question

这是一个面向对象设计模式专家的问题。

假设我有一个解析器类，负责读取/解析数据流（携带不同类型的信息包）。每个数据包都携带不同类型的信息，因此理想情况下，我会为每种类型的数据包创建一个类（PacketTypeA，PacketTypeB，…每个都有自己的接口）。

class Parser {

public:

    /* ctor */
    /* dtor */


   void read_packet(/* arguments */);

   // methods...
private:
   // more methods...
}

然后，方法Parser:：read_packet将遍历流，并将类（或指向类的指针或引用）返回到相应的包类型。

你会用空指针吗？一个泛型类（PacketBasicInterface）可以提供一个公共（部分）接口来查询数据包的类型（这样就可以在运行时做出任何决定），怎么样？

// Pure virtual (abstract) class to provide a common (and partial) interface
class PacketBasicInterface {
public:

    std::string whoAmI() const = 0;
    bool amIofType(const std::string& type) const = 0;

}

// Class to access data of type A packet
class PacketTypeA : public PacketBasicInterface {

public:
    // methodA_1()
    // methodA_2(), ...
}

// Class to access data of type A packet
class PacketTypeB : public PacketBasicInterface {

public:
    // methodB_1()
    // methodB_2(), ...
}

任何想法或反馈都将不胜感激！

非常感谢！

Answer 1

你会用空指针吗？

没有。

一个泛型类（PacketBasicInterface）可以提供一个公共（部分）接口来查询数据包的类型（这样就可以在运行时做出任何决定），这个类怎么样？

<罢工> 这对我来说最有意义。

让我来改进一下。是的，有一个通用基类会很好。但是，在解析流以构造基类的子类型时，不要依赖if-elsetype方法。相反，使用工厂模式。让不同的工厂基于一个键构造正确的对象类型，我假设这个键可以从正在解析的数据中获得。

如果您在数据中遇到字符串“PacketTypeA”，您会认为PacketTypeAFactory将负责构建对象。

FWIW，这种方法对于基类的许多子类型是可扩展的。我们在我的工作中使用这种方法，它已经为我们服务了二十多年。

下面是我想到的代码库的框架结构：

上课。

class PacketBasicInterface { };

class PacketTypeA : public PacketBasicInterface { };

class PacketTypeB : public PacketBasicInterface { };

工厂的界面。

// PacketFactory.h
class PacketFactory
{
   public:

      static PacketBasicInterface* makePacket(std::string const& packetData);

      static void registerFactory(std::string const& key, PacketFactory* factory);

      virtual PacketBasicInterface* make(std::string const& packetData) = 0;

      virtual ~PacketFactory() {}
};

实现使工厂工作的框架。

// PacketFactory.cpp

#include "PacketFactory.h"

namespace PacketBasicInterface_Impl
{
   using PacketFactoryMap = std::map<std::string, PacketFactory*>;

   PacketFactoryMap& getPacketFactoryMap()
   {
      static PacketFactoryMap theMap;
      return theMap;
   }
};

uisng namespace PacketBasicInterface_Impl;

PacketBasicInterface* PacketFactory::makePacket(std::string const& packetData)
{
   std::string key = extractKey(packetData);
   PacketFactoryMap& theMap = getPacketFactoryMap();
   PacketFactoryMap::iterator iter = theMap.find(key);
   if ( iter == theMap.end() )
   {
      return nullptr;
   }

   return iter->second->make(packetData);
}

void registerFactory(std::string const& key, PacketFactory* factory)
{
   getPacketFactoryMap()[key] = factory;
}

使用工厂模式制作PacketTypeA类型对象的代码。

// PacketTypeAFactory.cpp

#include "PacketFactory.h"
#include "PacketTypeA.h"

class PacketTypeAFactory : public PacketFactory
{
   public:

      virtual PacketBasicInterface* make(std::string const& packetData)
      {
         PacketTypeA* packet = new PacketTypeA();

         // Flesh out packet with data pulled from packetData
         // ...
         //

         return packet;
      }

      struct Initializer
      {
         Initializer() { PacketFactory::registerFactory("PacketTypeA", new PacketTypeAFactory); }
      };
};


// Constructing this object at static initialization time makes sure
// that PacketTypeAFactory is registered with PacketFactory when the
// stream data need to be parsed.
static PacketTypeAFactory::Initializer initializer;

制作PacketTypeB类型对象的代码与使用factory模式制作PacketTypeA类型对象的代码非常相似。

// PacketTypeBFactory.cpp


#include "PacketFactory.h"
#include "PacketTypeB.h"

class PacketTypeBFactory : public PacketFactory
{
   public:

      virtual PacketBasicInterface* make(std::string const& packetData)
      {
         PacketTypeA* packet = new PacketTypeA();

         // Flesh out packet with data pulled from packetData
         // ...
         //

         return packet;
      }

      struct Initializer
      {
         Initializer() { PacketFactory::registerFactory("PacketTypeB", new PacketTypeBFactory); }
      };
};


// Constructing this object at static initialization time makes sure
// that PacketTypeBFactory is registered with PacketFactory when the
// stream data need to be parsed.
static PacketTypeBFactory::Initializer initializer;

客户端代码。

std::string packetData;
while ( getPacketData(packetData) )
{
   PacketBasicInterface* packet = PacketFactory::makePacket(packetData);
   if ( packet == nullptr )
   {
      // Deal with error.
   }
   else
   {
      // Use packet
   }
}

Answer 2

如果您正在从面向对象程序设计领域寻找设计模式，双重分派可能是一种方法。
它遵循一个最小的工作示例：

#include<iostream>

struct Visitor;

struct PacketBasicInterface {
    virtual void accept(Visitor &) = 0;
};

struct PacketTypeA: PacketBasicInterface {
    void accept(Visitor &) override;
};

struct PacketTypeB: PacketBasicInterface {
    void accept(Visitor &) override;
};

struct Visitor {
    void visit(PacketTypeA) {
        std::cout << "PacketTypeA" << std::endl;
    }

    void visit(PacketTypeB) {
        std::cout << "PacketTypeB" << std::endl;
    }
};

void PacketTypeA::accept(Visitor &visitor) {
    visitor.visit(*this);
}

void PacketTypeB::accept(Visitor &visitor) {
    visitor.visit(*this);
}

struct Parser {
   PacketBasicInterface * read_packet() {
       return new PacketTypeB{};
   }
};

int main() {
    Visitor visitor;
    auto *packet = Parser{}.read_packet();
    packet->accept(visitor);
    delete packet;
}

Answer 3

这就是std:：variant的用途。

我将定义一个枚举类，枚举所有可能的数据包类型：

enum class packet_type {initialization_packet, confirmation_type, ... };

并让read_packet返回packet_类型的元组和变量：

typedef std::variant< ... > packet_info;

std::tuple<packet_type, packet_info> read_packet();

实际上不需要正式的枚举，但它可以更容易地找出如何处理变量。

这种一般方法的一些变化包括：

>

使用不透明的std:：string，而不是固定的枚举来指定数据包类型。

使用std:：any而不是正式的std:：variant。

与使用简单的枚举或不透明的标记（如std:：string）不同，使用一个稍微简单的类来定义数据包类型，该类的方法将变量元数据作为参数，并封装可以对数据包执行的操作。

当然，正如引用的链接所指出的，std::变体需要C 17。这将是您更新编译器的一个很好的论据：您获得了一种实现完全类型安全方法的简单方法。