Qt access D-Pointer of inherited Class

Question

I am trying to understand how the whole d-pointer thing i working. I got most parts but I am currently facing a problem:

Like the guy here Dpointer inheritance i want to inherit a class using d-pointers (infact it is QProcess).

Since the function to access the d-pointer is private i can not access it with simple inheritance. My idea is to again use the Q_DECLARE_PRIVATE macro to get the function and to access it. Can this work? Before I try out I want some hints since I dont know if this can even work.

(I need this to avoid the whole licensing issues.)

MyProcess.h

#ifndef MYPROCESS_H
#define MYPROCESS_H

class QProcessPrivate;

class MyProcess : public QProcess {
   public:
     MyProcess(QObject *parent = 0);

   protected:
     Q_DECLARE_PRIVATE(QProcessPrivate);

};

#endif /* WIDGET_H */

MyProcess.cpp

#include "myprocess.h"

MyProcess::MyProcess(QObject *parent = 0)
      : QProcess(parent) {
}

MyProcess::setPid(Q_PID pid) {
    Q_D(const QProcess);
    d->pid = pid;
}

Answer 1

It can be accessed by d_ptr.data(). I want to extend the behaviors of QML without recompiling Qt source code, which need access to d_ptr. Here's how I get the QTextDocument in d_ptr of QDeclarativeTextEdit in an inherit class:

QT_FORWARD_DECLARE_CLASS(QDeclarativeTextEditPrivate)
class MyTextEdit : public QDeclarativeTextEdit
{
  ...
  void aMethod()
  {
    QDeclarativeTextEditPrivate *d = reinterpret_cast<QDeclarativeTextEditPrivate *>(QDeclarativeItem::d_ptr.data());
    QTextDocument *d_doc = d->document;
    ...
  }
};

btw, we can also get d_ptr without inheriting classes. For example, here's how I get QTextDocument in QDeclaractiveTextEditPrivate without inheritance:

#include <QtGui/QGraphicsItem>
QT_FORWARD_DECLARE_CLASS(QGraphicsItemPrivate)
class DQGraphicsItem : public QGraphicsItem
{
  DQGraphicsItem() {}
public:
  QGraphicsItemPrivate *d() const { return d_ptr.data(); }
};

inline QGraphicsItemPrivate *d_qgraphicsitem(const QGraphicsItem *q)
{ return static_cast<const DQGraphicsItem *>(q)->d(); }

#include <qt/src/declarative/graphicsitems/qdeclarativetextedit_p.h>
#include <qt/src/declarative/graphicsitems/qdeclarativetextedit_p_p.h>

inline QDeclarativeTextEditPrivate *d_qdeclarativetextedit(const QDeclarativeTextEdit *q)
{ return static_cast<QDeclarativeTextEditPrivate *>(d_qgraphicsitem(q)); }

inline QTextDocument *d_qdeclarativetextedit_document(const QDeclarativeTextEdit *q)
{ return d_qdeclarativetextedit(q)->document; }

Answer 2

First of all, let's cover the basics. IANAL, but here it goes:

I presume that you have a closed-source application that wishes to use Qt under terms of LGPL.

Under some interpretations of U.S. law, making your code dependent on Qt's private headers makes it a derived work of Qt, so your code must be available under terms of LGPL (or GPL), unless you have a commercial license.

Your obligation under LGPL is to make it possible for people you distribute your app, to relink it with a version of Qt they compiled from the sources you're obliged to offer to them. This may be dynamic linking done by the OS, or static linking done with a linker utility. It doesn't matter whether you modified Qt or not. They ask, you must give them Qt sources with the exact build scripts you used to build the Qt that you use in your app.

When you depend on private headers, it's impossible for someone to make binary compatible changes to the Qt version you offer and relink it with your code, without things breaking. The private Qt classes can be changed without breaking binary compatibility - that's why they are private. Myself I interpret LGPL as follows: My code is not derived work if it will successfully link and work with any version of Qt that's binary-compatible to the version I offer along with my application. Of course that's within limits of Qt bugs and other changes I made, so it may not be viable for someone to patch this Qt to an older version and expect it to run OK.

So, the only thing you can do to keep your code closed-source is to modify the *public interface of QProcess within Qt proper. Anyone can take this modified version of Qt (that you offer!), make further binary compatible changes to it, and relink with your code. So if you think that not modifying Qt and depending on private headers makes your life easier, you are quite off base.

Generally speaking, you can't inherit from QXyzPrivate since you need to include Qt's private headers. So that's not a good practice, and there's really no good reason to do it. The price you pay is an extra heap allocation when you instantiate the class, so I'd say don't worry about it.

You must start your own private PIMPL class hierarchy. Note how each class that intends to be derived from must offer a constructor taking a reference to an instance of the private class.

// myprocess.h

class MyProcessPrivate;
class MyProcess : public QProcess {
  Q_DECLARE_PRIVATE(MyProcess) // No semicolon!
public:
  explicit MyProcess(int arg, QObject * parent = 0);
  ~MyProcess();
protected:
  MyProcess(MyProcessPrivate&, int arg, QObject * parent); // Must be present to allow derivation
  const QScopedPointer<MyProcessPrivate> d_ptr; // Only in the base class, must be protected!
}

// myprocess_p.h

class MyProcessPrivate {
  Q_DECLARE_PUBLIC(MyProcess) // No semicolon!
  ...
public:
  explicit MyProcessPrivate(MyProcess*);
protected:
  MyProcess * const q_ptr; // Only in the base class, must be protected!
};

// derivedprocess.h

#include "myprocess.h"

class DerivedProcessPrivate;
class DerivedProcess {
  Q_DECLARE_PRIVATE(DerivedProcess) // No semicolon!
public:
  explicit DerivedProcess(int arg, QObject * parent = 0);
  ~DerivedProcess();
}

// derivedprocess_p.h

#include "myprocess_p.h"

class DerivedProcessPrivate : public MyProcessPrivate {
  Q_DECLARE_PUBLIC(DerivedProcess) // No semicolon!
  //...
public:
  explicit DerivedProcessPrivate(DerivedProcess*);
};

// myprocess.cpp

MyProcess::MyProcess(int arg, QObject * parent) :
  QProcess(parent),
  d_ptr(new MyProcessPrivate(this)) {}

MyProcess::MyProcess(MyProcessPrivate & d, int arg) :
  d_ptr(&d) {}

MyProcessPrivate::MyProcessPrivate(MyProcess* parent) :
  q_ptr(parent) {}

// derivedprocess.cpp

DerivedProcess::DerivedProcess(int arg, QObject * parent) :
  MyProcess(* new DerivedProcessPrivate(this), arg, parent) {}

DerivedProcessPrivate::DerivedProcessPrivate(DerivedProcess* parent) :
  MyProcessPrivate(parent) {}