将对存储在QObject子类中

Question

My question refers to question Subclass of QObject, qRegisterMetaType, and the private copy constructor . According to it, it should be possible to register a subclass of QObject as a meta-type, that a QVariant can store. I have this code:

#ifndef MODELROWREFERENCE_HPP
# define MODELROWREFERENCE_HPP

#include <QObject>

#include <QDataStream>

class ModelRowReference :
  public QObject
{
  Q_OBJECT

  Q_PROPERTY(QObject* model READ model WRITE setModel)
  Q_PROPERTY(int row READ row WRITE setRow)

public:
  ModelRowReference(QObject* = 0);
  ModelRowReference(QObject*, int, QObject* = 0);

  ModelRowReference(ModelRowReference const&);

  QObject* model() const;
  void setModel(QObject*);

  int row() const;
  void setRow(int);

private:
  QObject* model_;
  int row_;
};

Q_DECLARE_METATYPE(ModelRowReference)

//////////////////////////////////////////////////////////////////////////////
inline ModelRowReference::ModelRowReference(QObject* parent) :
  QObject(parent),
  model_(0)
{
}

//////////////////////////////////////////////////////////////////////////////
inline ModelRowReference::ModelRowReference(QObject* m, int r,
  QObject* parent) :
  QObject(parent),
  model_(m),
  row_(r)
{
}

//////////////////////////////////////////////////////////////////////////////
inline ModelRowReference::ModelRowReference(ModelRowReference const& other) :
  QObject(other.parent()),
  model_(other.model_),
  row_(other.row_)
{
}

//////////////////////////////////////////////////////////////////////////////
inline QObject* ModelRowReference::model() const
{
  return model_;
}

//////////////////////////////////////////////////////////////////////////////
inline void ModelRowReference::setModel(QObject* m)
{
  model_ = m;
}

//////////////////////////////////////////////////////////////////////////////
inline int ModelRowReference::row() const
{
  return row_;
}

//////////////////////////////////////////////////////////////////////////////
inline void ModelRowReference::setRow(int r)
{
  row_ = r;
}

//////////////////////////////////////////////////////////////////////////////
inline QDataStream& operator<<(QDataStream& out, ModelRowReference const& p)
{
  QObject* model(p.model());

  out << QByteArray(reinterpret_cast<char const*>(&model), sizeof(model));
  out << p.row();

  return out;
}

//////////////////////////////////////////////////////////////////////////////
inline QDataStream& operator>>(QDataStream& in, ModelRowReference& r)
{
  QByteArray a;

  in >> a;

  r.setModel(*reinterpret_cast<QObject**>(a.data()));

  int row;

  in >> row;

  r.setRow(row);

  return in;
}

#endif // MODELROWREFERENCE_HPP

but it doesn't even compile:

modelrowreference.hpp:36:1: error: expected constructor, destructor, or type conversion before 'inline'

Is the answer, that this can be done wrong, or am I doing something wrong? I know I could have gone the pointer way (registering ModelRowReference*), but who then is going to delete the pointer? Thousands of instances of ModelRowReference might be created, while the model object lifetime extends until the end of the program.

What I am trying to achieve is exposing the pair (model, row) to a QML program. If I do it via QPair, the QML program is unable to access the members of the pair.

I am using Qt4.8.

Answer 1

您可能需要#include <QMetaType> 。