Q_D: d-pointer private in this context?

[fonzi337]

Hi,

I am trying to implement the D-pointer pattern for some of my classes. I've followed the tutorials http://zchydem.enume.net/2010/01/19/...nd-d-pointers/ and http://techbase.kde.org/Policies/Lib...ointer_Example but whenever I access a private member of my d-pointer, a compiler error results stating that the member is private in the given context. Q_DECLARE_PRIVATE is supposed to make my XYZPrivate class a friend of my XYZ class, so why is there a problem accessing its private data members?

Here's the relevant code:

Employer.h:

class EmployerPrivate;
 
class Employer : public Loggable
{
public:
    Employer(QString name, QString market);
    ~Employer();
 
    QList<Position> findJobs() const;
    QString toString() const;
    bool hire(Person& newHire, Position pos);
 
protected:
    const QScopedPointer<EmployerPrivate> d_ptr;
 
private:
    Q_DECLARE_PRIVATE(Employer)
};

class EmployerPrivate;

class Employer : public Loggable
{
public:
    Employer(QString name, QString market);
    ~Employer();

    QList<Position> findJobs() const;
    QString toString() const;
    bool hire(Person& newHire, Position pos);

protected:
    const QScopedPointer<EmployerPrivate> d_ptr;

private:
    Q_DECLARE_PRIVATE(Employer)
};

To copy to clipboard, switch view to plain text mode 

Employer.cpp:

Employer::Employer(QString name, QString market) :
    d_ptr(new EmployerPrivate(name, market))
{
}
 
Employer::~Employer()
{
}
 
QList<Position> Employer::findJobs() const
{
    Q_D(const Employer);
    return d->m_positions;    // Compiler error: m_positions private within context
}
 
QString Employer::toString() const
{
    Q_D(const Employer);
    return QString("***Employer information***\nName: %1\nMarket: %2").arg(d->m_name).arg(d->m_market); // Compiler error
}

Employer::Employer(QString name, QString market) :
    d_ptr(new EmployerPrivate(name, market))
{
}

Employer::~Employer()
{
}

QList<Position> Employer::findJobs() const
{
    Q_D(const Employer);
    return d->m_positions;    // Compiler error: m_positions private within context
}

QString Employer::toString() const
{
    Q_D(const Employer);
    return QString("***Employer information***\nName: %1\nMarket: %2").arg(d->m_name).arg(d->m_market); // Compiler error
}

To copy to clipboard, switch view to plain text mode 

EmployerPrivate.h:

class EmployerPrivate
{
public:
    EmployerPrivate(QString name, QString market);
 
private:
    QList<Position> m_positions;
    QString m_name;
    QString m_market;
};

class EmployerPrivate
{
public:
    EmployerPrivate(QString name, QString market);

private:
    QList<Position> m_positions;
    QString m_name;
    QString m_market;
};

To copy to clipboard, switch view to plain text mode 

EmployerPrivate.cpp:

EmployerPrivate::EmployerPrivate(QString name, QString market) :
    m_name(name),
    m_market(market)
{
}

EmployerPrivate::EmployerPrivate(QString name, QString market) :
    m_name(name),
    m_market(market)
{
}

To copy to clipboard, switch view to plain text mode 

I've tried making both classes derive from QObject and added the Q_OBJECT macro just in case (even though, from my understanding, these aren't needed), but that also did not work.

[ChrisW67]

Q_DECLARE_PRIVATE cannot possibly make Employer a friend of EmployerPrivate: to do that it would have to be inside the EmployerPrivate class. It does make EmployerPrivate a friend of Employer, i.e. the EmployerPrivate class can access the Employer private members.

Q_DECLARE_PUBLIC inside the private class has the effect you are seeking. However, you'll find the ClassPrivate class contents are public in the examples you linked to.

[Lykurg]

Well the error message seems clear to me! m_positions is private. Solution: make it public. Thus you have to delete private: from the class EmployerPrivate. As most private classes only have public members.


EDIT: refresh before posting can help...

[MarekR22]

Pattern looks like this:

// public Header file for  SomeLibBaseClass
class SomeLibBaseClassPrivate;
 
class SomeLibBaseClass : public LibExternalClass {
     ...
protected:
     SomeLibBaseClassPrivate *d_ptr; // or QScopedPointer<SomeLibBaseClassPrivate>
     SomeLibBaseClass(SomeLibBaseClassPrivate &dd, other args); // needed for subclassing inside library
 
private:
     Q_DISABLE_COPY(SomeLibBaseClass)
     Q_DECLARE_PRIVATE_D(d_ptr, SomeLibBaseClass)
}
 
// -------------------------------------------------
// private header file for SomeLibBaseClass
 
class SomeLibBaseClass;
 
class SomeLibBaseClassPrivate {
 
   Q_DECLARE_PUBLIC(SomeLibBaseClass)
 
public:
    SomeLibBaseClassPrivate();
 
    virtual ~SomeLibBaseClassPrivate(); // !!! OBLIGATORY virtual destructor. HAVE to do it if you want avoid strange hard to locate errors
 
    // in general private class shouldn't have virtual methods (except destructor which is obligatory)
    // It is never a Q_Object, it doesn't have meta data
 
    SomeLibBaseClass *q_ptr;
}
 
// -------------------------------------------------
// public Header file for  SomeLibSubClass
 
class SomeLibSubClassPrivate;
 
class SomeLibSubClass : public SomeLibBaseClass {
 
protected:
    SomeLibSubClass(SomeLibSubClassPrivate &dd, otherArgs); // needed for subclassing inside lib
 
private:
    Q_DECLARE_PRIVATE_D(d_ptr, SomeLibSubClass)
    // no new d_pointer, it is inherited
};
 
// -------------------------------------------------
// private header file for  SomeLibSubClass
#include "somelibbaseclass.h"
class SomeLibSubClass;
 
class SomeLibSubClassPrivate : public SomeLibBaseClassPrivate {
 
   Q_DECLARE_PUBLIC(SomeLibSubClass)
 
public:
    SomeLibSubClassPrivate();
 
    ~SomeLibBaseClassPrivate(); // here is optional
 
    // q pointer is not needed, it is inharited
}

// public Header file for  SomeLibBaseClass
class SomeLibBaseClassPrivate;

class SomeLibBaseClass : public LibExternalClass {
     ...
protected:
     SomeLibBaseClassPrivate *d_ptr; // or QScopedPointer<SomeLibBaseClassPrivate>
     SomeLibBaseClass(SomeLibBaseClassPrivate &dd, other args); // needed for subclassing inside library

private:
     Q_DISABLE_COPY(SomeLibBaseClass)
     Q_DECLARE_PRIVATE_D(d_ptr, SomeLibBaseClass)
}

// -------------------------------------------------
// private header file for SomeLibBaseClass

class SomeLibBaseClass;

class SomeLibBaseClassPrivate {

   Q_DECLARE_PUBLIC(SomeLibBaseClass)

public:
    SomeLibBaseClassPrivate();

    virtual ~SomeLibBaseClassPrivate(); // !!! OBLIGATORY virtual destructor. HAVE to do it if you want avoid strange hard to locate errors

    // in general private class shouldn't have virtual methods (except destructor which is obligatory)
    // It is never a Q_Object, it doesn't have meta data

    SomeLibBaseClass *q_ptr;
}

// -------------------------------------------------
// public Header file for  SomeLibSubClass

class SomeLibSubClassPrivate;

class SomeLibSubClass : public SomeLibBaseClass {

protected:
    SomeLibSubClass(SomeLibSubClassPrivate &dd, otherArgs); // needed for subclassing inside lib

private:
    Q_DECLARE_PRIVATE_D(d_ptr, SomeLibSubClass)
    // no new d_pointer, it is inherited
};

// -------------------------------------------------
// private header file for  SomeLibSubClass
#include "somelibbaseclass.h"
class SomeLibSubClass;

class SomeLibSubClassPrivate : public SomeLibBaseClassPrivate {

   Q_DECLARE_PUBLIC(SomeLibSubClass)

public:
    SomeLibSubClassPrivate();

    ~SomeLibBaseClassPrivate(); // here is optional

    // q pointer is not needed, it is inharited
}

To copy to clipboard, switch view to plain text mode 

macro Q_DECLARE_PRIVATE_D and Q_DECLARE_PUBLIC (you didn't use that macro that is why you have a problem, don't forget about q_pointer) provides friendship between public and private class. You should use both.

It would be the best if you take a look how Qt is written. There you have all cases of d_pointer usage.
For example objects with implicit data sharing (like QString, QByteArray, QVector, QList) have a different set of roles.

[fonzi337]

Thank you MarekR22, that works great. I'm wondering though: is q_pointer required? I thought that was only necessary if the private class needed to access the private members of the public class. Do I still need to include q_pointer if my private class does not need to access the public class' private members (since I get a compiler error when I take out the q_pointer, it seems like it does need it; I'd just like to understand better why it is needed)?

Thanks!

[ChrisW67]

The public class will generally have no private members other than the d pointer.

The q pointer is primarily used to access the signals of the publicly visible class, which are declared protected in the public class, from the private impl class. This is a convenience.. otherwise the impl class would have to emit signals, that were connected to trigger the public class signal of the same function.

[fonzi337]

Thanks for the explanation Chris, that makes a lot of sense.