C ++继承和抽象类

Question

我有一个抽象类Interface 。 接口具有read方法并读取数据并对其进行解析，而getData方法则实际返回已解析的数据。 每个接口都有一个Parser对象，可以执行实际的解析。 解析器具有parse方法和用于解析数据的吸气剂。
该班USBInterface和SerialInterface继承Interface 。

问题：
我如何可以使用不同的解析器USBInterface和SerialInterface ？
有两个解析器， USBParser和SerialParser ，它们继承自Parser 。

我当前的解决方案在Interface构造函数中初始化的Interface基类中使用Parser引用，但是我不确定这是否是最佳方法。

 class Parser {
  public:
    Parser() {}
    int getData() {
      return data;
    }
  protected:
    int data;
};

class USBParser : public Parser {
  public:
    USBParser() {}
    bool parse(uint8_t *usbpacket) {
      data = usbpacket[1]; // Do the actual parsing here
      return true; // Return true if data is complete
    }
};

class SerialParser : public Parser {
  public:
    SerialParser() {}
    bool parse(uint8_t databyte) {
      data = databyte; // Do the actual parsing here
      return true; // Return true if data is complete
    }
};

class Interface {
  public:
    Interface(Parser &parser) : parser(parser) {}
    virtual bool read() = 0;
    int getData() {
      return parser.getData();
    }
  protected:
    Parser &parser;
};

class USBInterface : public Interface {
  public:
    USBInterface() : Interface(parser) {}
    bool read() {
      uint8_t usbpacket[4] = {0x00, 0x01, 0x02, 0x03}; // Read raw data from USB
      return parser.parse(usbpacket);
    }
  private:
    USBParser parser;
};

class SerialInterface : public Interface {
  public:
    SerialInterface() : Interface(parser) {}
    bool read() {
      uint8_t databyte = 0xFF; // Read raw data from serial port
      return parser.parse(databyte);
    }
  private:
    SerialParser parser;
};

int main() {
  USBInterface usb;
  SerialInterface serial;

  if (usb.read())
    println(usb.getData());
  if (serial.read())
    println(serial.getData());
}

我的方法是否有缺陷，或者有更好的方法？

Answer 1

您的代码对我来说有点复杂。 相反，你可以使用依赖注入的类USBInterface取决于USBParser像明智SerialInterface取决于SerialParser 。 它给您更多的灵活性。 如果你有类似GenericParser要与使用USBInterface或SerialInterface 。

class Parser {
  public:
    Parser() {}
    int getData() {
      return data;
    }
  protected:
    int data;
};

class USBParser : public Parser {
  public:
    USBParser() {}
    bool parse(uint8_t *usbpacket) {
      data = usbpacket[1]; // Do the actual parsing here
      return true; // Return true if data is complete
    }
};

class SerialParser : public Parser {
  public:
    SerialParser() {}
    bool parse(uint8_t databyte) {
      data = databyte; // Do the actual parsing here
      return true; // Return true if data is complete
    }
};

class Interface {
  public:
    Interface(Parser &parser) : parser(parser) {}
    virtual bool read() = 0;
    int getData() {
      return parser.getData();
    }
  protected:
    Parser &parser;
};

class USBInterface : public Interface {
  public:
    USBInterface(Parser &parser) : Interface(parser) {}
    bool read() {
      uint8_t usbpacket[4] = {0x00, 0x01, 0x02, 0x03}; // Read raw data from USB
      return parser.parse(usbpacket);
    }
};

class SerialInterface : public Interface {
  public:
    SerialInterface(Parser &parser) : Interface(parser) {}
    bool read() {
      uint8_t databyte = 0xFF; // Read raw data from serial port
      return parser.parse(databyte);
    }
};

int main() {
  USBParser usbParse
  USBInterface usb(usbParse);

  SerialParse serialParse;
  SerialInterface serial(serialParse);

  // GenericParse parse;
  // SerialInterface serial(parse);

  if (usb.read())
    println(usb.getData());
  if (serial.read())
    println(serial.getData());
}