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

这就是 std：：variant 的用途。

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

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

并且read_packet返回一个packet_type元组和一个变体：

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

实际上不需要正式的枚举，但它可以更轻松地弄清楚如何处理变体。

此一般方法的一些变体包括：

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

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

3. 不要使用简单的枚举或像std::string这样的不透明令牌，而是使用稍微不平凡的类来定义数据包类型，该类的方法将变体元数据作为参数，并封装可以在数据包上执行的操作。

当然，如引用链接中所述，std::variant需要C++17。这对于您更新编译器来说是一个很好的论据：您可以获得一种实现完全类型安全方法的简单方法。

如果您正在寻找面向对象编程领域的设计模式，那么双重调度可能是要走的路。
它遵循一个最小的工作示例：

#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;
}

你会为此使用空指针吗？

不。

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

这对我来说最有意义。

让我对此进行完善。是的，拥有一个泛型基类会很好。但是，在分析流以构造基类的子类型时，不要依赖if-else类型方法。而是使用工厂模式。让各个工厂基于键构造正确的对象类型，我假设可以从正在解析的数据中获得。

如果在数据中遇到字符串"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 类型的对象的代码与 用于使用工厂模式创建 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
}
}