模板类 C++ /Qt

Question

我有一个应用程序将接收来自另一个应用程序的消息。这些消息将是 XML 格式的字符串，并且它们将包含 标记。消息类型将将此消息标识为内部消息的类型。以下代码显示了我的内部消息结构。

namespace
Application1{

enum ApplicationAttributes{
    ApplicationName = 1000,
    Start,
    Stop,
    Pause,
    Save,
    Discard,
    SelectRunway,
    DoAlignment,
    RedoAlignment,
    AlignmentOK,
    DoCalibrationStage1,
    SetCalibrationStage1,
    SetCalibrationStage2,
    SetCalibrationStage3,
    CancelCalibration,
    CalibrationOK
};


struct Alignment{
    int x;
    int y;
    int error;
};

struct Calibration{
    int x;
    int y;
    int error;
};

}

对齐和校准是两种内部消息结构。

我想做的是构建一个“消息解释器”，它将接收 XML 字符串，对其进行解码并返回上面显示的任何一个结构；因此，如果 是“alignment”，消息解释器将构建一个对齐结构并返回该结构。

所以最终，我试图创建一个模板函数，它可以根据我从 读取的内容返回任意结构。

我的目标明确吗？我的方法正确吗？

让我知道是否应该澄清，或者是否应该采取不同的方法。

Answer 1

我不认为模板函数有意义。您的输入始终是一个字符串，而 C++ 无法仅根据返回类型来区分函数签名 - 所以我不知道模板有何帮助 - 类型参数是什么？

我建议让你的函数成为一个普通的函数，解析出 messageType 并根据它分配一个结构 - 你可以使用任何你想要的结构。

诀窍是（在我看来）从同一个空基类派生所有内部消息类 - 然后您可以从函数返回指向该基类的指针，并且它将保存创建的任何类型。

最好在 std::pair 中返回一个枚举和指针，您可以使用它来确定创建的正确派生类型，这样您就可以使用 static_cast 将结果直接转换为正确的派生类型。

Answer 2

据我了解，您的结构在应用程序中是已知的，那么这个保存变体怎么样：（

class Message {
public:
    static Message Alignment (alignment_t const &);
    ...
    Type type() const;

    int alignment() const;

private:
    Message (Type t);
    assert_type (Type t, const char *msg) const;

private:
   Type type_;
};

Message Message::Alignment (alignment_t const &alignment) 
{
    Message ret (Type::Alignment);
    ret.alignment_ = alignment;
    return ret;
}

void Message::assert_type (Type t, const char *msg) const
{
    if (type() != t) throw std::runtime_error (msg);
}

int Message::alignment() const
{
    assert_type (Type::Alignment, 
                 "alignment_x() called for non-alignment-message");
    return alignment_;
}

未经验证而编码以给您想法）

这无需多态性即可工作（我在类似 LISP 的语言的编译器中使用此模式，其中多态树会导致更复杂的代码）。如果您更喜欢的话，您可以将其更改为返回“alignment_x()”等。

完全动态的结构是不可能的，并且试图接近的解决方案将相当复杂。使用最易于维护的解决方案。

Answer 3

如果您为每种类型编写一个工厂函数/函子，则可以将其与 messageType 关联起来（map 就足够了），但是要做什么返回？

如果您不介意顶级解码器取决于所有可能的消息类型，则可以返回某种可区分的联合或 boost::variant。

但是，解码器将如何处理这个返回值呢？如果它只是打开类型并在每种情况下调用特定于类型的回调，则可以通过直接将回调函数/函子附加到工厂来反转控制。

然后解码器不会返回任何内容，它只是构造消息 struct 并将其直接传递给处理程序。

简单的实现（好吧，打字比我想象的要多）：

class Decoder
{
public:
  virtual ~Decoder();
  virtual void decode(std::string const &xml) = 0;
};

template <typename Factory, typename Callback>
class SimpleDecoder: public Decoder
{
  Factory factory;
  Callback callback;
public:
  SimpleDecoder(Factory f, Callback c)
  : factory(f), callback(c)
  {}

  void decode(std::string const &xml)
  {
    callback( factory( xml ) );
  }
};

std::map<std::string, Decoder*> factories;

template <typename F, typename C>
void registerSimpleDecoder(std::string const &n, F f, C c)
{
  factories[n] = new SimpleDecoder(f, c);
}

void decodeXmlMessage(std::string const &messageType, std::string const &body)
{
  factories[messageType]->decode(body);
}

Answer 4

使用dynamic_cast 将其转换为您的类

class MyClass : public QObject{
    public:
    enum Type{ MyClassType = UserType + 1 }
    Q_INVOKABLE MyClass();
}
Q_DECLARE_METATYPE ( MyClass )

使用 QMetaObject::newInstance，因此您可以创建一个 QObject*，然后可以在您的 XML 解析代码中

MyClass* myObject = (MyClass*) QMetaType::construct ( MyClass::MyClassType );

：事情就会解决。