5

我正在开发一个实现专有协议的服务器项目。服务器是用 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_factory::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. 使用访问者模式实现“智能指针”来处理从 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<> 向下转换对我们来说是最简单的方法，但是我们都不喜欢这个想法，因为我们都觉得向下转换是“邪恶的”。然而，没有人能准确地解释为什么它是“邪恶的”。

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

4

3 回答 3

2

http://en.wikipedia.org/wiki/Circle-ellipse_problem是你第一个邪恶的例子。如果你发现你可以做一些违反基本原则的事情，那么你应该发明另一个轮子或尝试另一顶帽子：http ://en.wikipedia.org/wiki/Six_Thinking_Hats

于 2011-05-22T17:20:39.710 回答
0

向下转型，尤其是在工厂模式实现中，对我来说非常有意义。它实际上与“程序到接口”的思想很好地融合在一起。不知道为什么人们觉得沮丧是不好的。检查逆变，因为这就是您正在查看的内容。

于 2011-05-22T14:36:24.230 回答
0

问题是 legacy_parser 在原始解析器中需要两帧而不是一帧。因此，一种可能的解决方案是稍微更改您的原始解析器并使其适用于多个帧。例如，如果解析器需要更多帧，则 parse 可能会返回一个预定义的常量，然后 legacy_parser 可以这样实现：

class legacy_parser : public parser {
 public:
  int parse(unsigned char *str) {
    if (parse_header_) {
      // store str in header_
      parse_header_ = false;
      return kExpectMoreFrames;
    } else {
      return parse(header_, str);
    }
  }
 private:
  int parse(unsigned char *header, unsigned char *parload) {
    // ...
  }
  bool parse_header_;
  unsigned char *header_;
};

如果现有的解析器代码没有意外使用为“更多帧”的含义定义的值，则它们不应受到影响。

于 2011-05-23T13:33:02.587 回答