在使用工厂模式时，我应该避免以任何方式进行下转换吗

我正在处理一个实现专有协议的服务器项目。服务器是用C++中的工厂模式实现的，我们现在面临着下转换的问题。

我正在研究的协议是为在慢速网络上进行自动控制而设计的，如RS485、ZigBee、窄带PLC等。我们设计了工厂模式的主服务器。当接收到一个新帧时，我们首先识别该帧的相关设备类型，调用工厂方法来生成一个新的"解析器"实例，并将该帧调度到解析器实例。

我们的专有协议是以纯二进制实现的，我们可能需要的每一个信息都记录在帧本身中，因此可以尽可能简单地定义基本接口。我们还将为我们的工厂实现自动注册方法（此处省略了与std:：map操作相关的详细代码）：

// This is our "interface" base-class
class parser
{
public:
    virtual int parse(unsigned char *) = 0;
    virtual ~parser() { }
};
// The next two classes are used for factory pattern
class instance_generator
{
public:
    virtual parser *generate() = 0;
};
class parser_factory
{
private:
    static std::map<int,instance_generator*> classDB;
public:
    static void add(int id, instance_generator &genrator);
    parser *get_instance(int id);
};
// the two template classes are implementations of "auto-regisrtation"
template <class G, int ID> class real_generator : public instance_generator
{
public:
    real_generator()    {   parser_factory::add(ID,this);   }
    parser *generate()  {   return new G;   }
};
template <class T, int N> class auto_reg : virtual public parser
{
private:
    static real_generator<T,N> instance;
public:
    auto_reg() { instance; }
};
template <class T, int N> parser_generator<T,N> auto_reg<T,N>::instance;

// And these are real parser implementations for each device type
class light_sensor : public auto_reg<light_sensor,1>
{
public:
    int parse(unsigned char *str)
    {
        /* do something here */
    }
};
class power_breaker : public auto_reg<power_breaker,2>
{
public:
    int parse(unsigned char *str)
    {
        /* do something here */
    }
};
/* other device parser */

这种工厂模式运行得很好，而且很容易扩展新的设备类型。

然而，最近我们正在尝试与现有的控制系统接口，以提供类似的功能。目标系统相当陈旧，它只提供一个基于ASCII的、类似AT命令的串行接口。我们已经设法解决了PTY的通信问题，但现在要解决的问题是解析器的实现。

目标系统的命令界面非常有限。我不能只是等待和收听即将到来的内容，我必须轮询州，并且我必须轮询两次——第一次轮询报头，第二次轮询有效载荷——才能获得完整的命令。这对我们的实现来说是个问题，因为我必须将两个帧传递到解析器实例中，这样它才能工作：

class legacy_parser : virtual public parser
{
public:
    legacy_parser() { }
    int parse(unsigned char *str)
    {
        /* CAN NOT DO ANYTHING WITHOUT COMPLETE FRAMES */
    }
    virtual int parse(unsigned char *header, unsigned char *payload) = 0;
};
class legacy_IR_sensor : 
    public legacy_parser,
    public auto_reg<legacy_IR_sensor,20>
{
public:
    legacy_IR_sensor(){ }
    int parse(unsigned char *header, unsigned char *payload)
    {
        /* Now we can finally parse the complete frame */
    }
};

换句话说，我们需要调用派生类的方法，而该方法没有在基类中定义。我们使用工厂模式来生成派生类的实例。

现在我们有几个选择：

1. 简单地将两个字符串连接为一个字符串是行不通的。这两个字符串都包含一些设备指定的信息，它们应该单独解析。如果我们采用这种方法，在连接字符串之前，我们将对解析器实例进行一些"预解析"。我们认为这不是一个好主意。

2. 将parser_filter:：get_instance（）的返回向下转换为legacy_parser。

3. 创建另一个独立的工厂，该工厂仅包含从legacy_parser派生的类。

4. 更改instance_generator和parser_factory的定义，使它们也可以生成（legacy_parser*），同时保持所有现有代码不受影响：

   class instance_generator
   {
   public:
       virtual parser *generate() = 0;
       virtual legacy_parser *generate_legacy() { return NULL; }
   };
   class extended_parser_factory : public parser_factory
   {
   public:
       legacy_parser *get_legacy_instance(int id);
   };
   

5. 使用Visitor模式实现"智能指针"以处理从legacy_parser:派生的实例

   class smart_ptr
   {
   public:
       virtual void set(parser *p) = 0;
       virtual void set(legacy_parser *p) = 0;
   };
   class parser
   {
   public:
       parser() { }
       virtual int parse(unsigned char *) = 0;
       virtual void copy_ptr(smart_ptr &sp)    // implement "Visitor" pattern
       {
           sp.set(this);
       }
       virtual ~parser() { }
   };
   class legacy_parser : virtual public parser
   {
   public:
       legacy_parser() { }
       void copy_ptr(smart_ptr &sp)    // implement "Visitor" pattern
       {
           sp.set(this);
       }
       int parse(unsigned char *str)
       {
           /* CAN NOT DO ANYTHING WITHOUT COMPLETE FRAMES */
       }
       virtual int parse(unsigned char *header, unsigned char *payload) = 0;
   };
   class legacy_ptr : public smart_ptr
   {
   private:
       parser *miss;
       legacy_parser *hit;
   public:
       legacy_ptr& operator=(parser *rhv)
       {
           rhv->copy_ptr(*this);
           return *this;
       }
       void set(parser* ptr)
       {
           miss=ptr;
           /* ERROR! Do some log or throw exception */
       }
       void set(legacy_parser *ptr)
       {
           hit = ptr;
       }
       legacy_parser& operator*()
       {
           return *hit;
       }
       ~legacy_ptr()
       {
           if(miss) {
               delete miss;
           }
           if(hit) {
               delete hit;
           }
       }
   };
   

很明显，使用dynamic_cast<>的Downcasting对我们来说，这是最简单的方法，但我们都不喜欢这个想法，因为我们都觉得贬低某些东西是"邪恶的"。然而，没有人能够确切地解释为什么它是"邪恶的"

在我们做出决定之前，我希望听到更多关于这些选项的评论。