Как стать автором
Обновить

Приватные слоты в паттерне Pimpl от Qt

Qt *

Вступление.


Недавно я писал по поводу реализации паттерна Pimpl в библиотеке Qt и призывал людей следовать такому подходу при разработке их собственных бибиотек. Теперь я хочу поговорить о таком понятии, как приватные слоты и тем самым продолжить эту тему. Заключительной статьей на эту тему будет реализация механизма Implicit Sharing и shared d-pointer.

Что это и зачем это нужно.


Приватные слоты — это механизм дополняющий функционал d-указателей. Он позволяет реализовать слоты для приватного класса, даже если он не является наследником от QObject (обычно он им и не является), но для этого публичный класс должен быть наследником от QObject. Тоесть по факту создается некий приватный слот в публичном классе и он непосредственно дергает нужный метод приватного класса.
Зачем это нужно? Ну рассмотрим на примере. Есть класс QAbstractScrollArea. Он просто отображает некий виджет (viewport) и обеспечивает прокрутку. Прокрутка обеспечивается с помощью двух экземпляров класса QScrollBar. Сами эти скролбары он хранит в приватном классе. Теперь проблемма: как подключить сигнал от скроллбара об изменение его позиции с классом QAbstractScrollAreaPrivate, ведь он не является QObject'ом? Сделать его наследником от QObject — лучше не делайте это :-). Можно сделать слот в публичном классе и повесить на него, то в таком случае это не очень красиво — так как наружу выходят слоты от внутренней реализации. Вот ту Qt-шниками был придуман достаточно разумный и элегантный подход — приватные слоты.



Как это работает.


Для реализации приватного слота служит макрос Q_PRIVATE_SLOT. Ну по нашему обычаю залазим в исходники Qt и смотрим что он из себя представляет:

# define Q_PRIVATE_SLOT(d, signature)


Опа!!! Пусто :-). Но настоящие мужчины никогда не отчаиваются и лезут в исходники глубже, а точнее в исходники moc. Кто не знает, moc — это некая реализация некого парсера. Только немного хитрая. В отличие от инструментов использующих QLALR (QSA и QXmlStreamReader ) — эта штука оказалась своеобразной. Я не силент в парсерах поэтому более глобальный анализ провести не могу. Но он точно не похож на LALR потому-что я не нашел лексики его. Таблица токенов генерится некой утилитой generate_keywords, которую можно найти в исходниках moc в папке util.
Насколько я понял он просто генерит из любого текста токены и формирует из них структуру вида:
static const struct
{
  Token token;
  short next;
  char defchar;
  short defnext;
  Token ident;
}


Вот пример записей этого генератора:
  {Q_SIGNAL_TOKEN, 0, 83, 470, CHARACTER},
  {Q_SIGNALS_TOKEN, 0, 0, 0, CHARACTER},
  {Q_SLOT_TOKEN, 0, 83, 474, CHARACTER},
  {Q_SLOTS_TOKEN, 0, 0, 0, CHARACTER},
  {Q_PRIVATE_SLOT_TOKEN, 0, 0, 0, CHARACTER},


Кто хочет покапать дальше или вообще уже знает ответ — прошу высказыватся.
Кстати очень просто оказалось это все дело расширить :-) можно добавить свой препроцессинг. Вот что значит писать красиво.

в token.cpp находим наш токен:
case Q_PRIVATE_SLOT_TOKEN: return "Q_PRIVATE_SLOT_TOKEN";


И далее в реализации метода MOC::parse() находим что же он делает, когда встречает этот парсер:
       case Q_PRIVATE_SLOT_TOKEN:
          parseSlotInPrivate(&def, access);
          break;



Ну вот и добрались до сути, она находится в методе parseSlotInPrivate(&def, access);
Вот и она:
void Moc::parseSlotInPrivate(ClassDef *def, FunctionDef::Access access)
{
  next(LPAREN);
  FunctionDef funcDef;
  next(IDENTIFIER);
  funcDef.inPrivateClass = lexem();
  // also allow void functions
  if (test(LPAREN)) {
    next(RPAREN);
    funcDef.inPrivateClass += "()";
  }
  next(COMMA);
  funcDef.access = access;
  parseFunction(&funcDef, true);
  def->slotList += funcDef;
  while (funcDef.arguments.size() > 0 && funcDef.arguments.last().isDefault) {
    funcDef.wasCloned = true;
    funcDef.arguments.removeLast();
    def->slotList += funcDef;
  }
}


* This source code was highlighted with Source Code Highlighter.


Вот теперь все ясно. Как вы видите эта директива заполняет нужные значения для определения метафункции, которая генерируется moc'ом ( таким же образом как и для обычных слотов ). А пустой дефайн просто делает эту запись пустой, когда moc прошел и настает время предкомпилятору. Тоесть на момент стандартной компиляции там уже пусто, но реализация слота сгенерирована в moc файле. Далее я покажу как она выглядит в нашем примере.
Ну вобщем разобрались с тем как это устроено, далее будет смотреть как это использовать.

Как реализовать это в своем коде.


Тут в дейсвтительности все очень просто. В качестве примера берем классы из моей предыдущей статьи . И добавляем новый функционал.
1. Добавляем метод void _q_boo() в MyClassPrivare:
class MyClassPrivate
{
  Q_DECLARE_PUBLIC(MyClass);
public:
  MyClassPrivate();
  virtual ~MyClassPrivate();

  void foo();
  void _q_boo();
  int i;
  MyClass * q_ptr;
};


* This source code was highlighted with Source Code Highlighter.


Реализация в myclass.cpp будет выглядеть таким образом:
void MyClassPrivate::_q_boo()
{
  qDebug()<<i;
  QCoreApplication::exit(1);
}


Не забудте добавить QDebug и QCoreApplication в инклуды.
По поводу имени _q_boo. Это правило именования приватных слотов от qt. Имя должно начинатся на "_q_". Тогда при просмотре объявления приватного класса можно определить что это слот.
QCoreApplication::exit(1) — я добавил для того чтобы при сраватывании мы завершили основной цикл приложения (далее напишу листинг этого приложения для тестирования нашей библиотеки).
2. Для большей запутаности ( а то сильно просто все получается ) давайте дерганье этого слота реализуем в наследнике — MyClassDerived. Для этого объявим у него в приватной секции такой вот макрос:
  Q_PRIVATE_SLOT(d_func(),void _q_boo());


Из вышеуказанного реверс инжиниринга moc мы тут видим, что нам нужен указатель на класс и имя его метода. По факту это простой текстовый анализ на основании которого потом сгенерируется код moc_myclassderived.cpp.
3. Попробуем собрать наш проект:
moc_myclassderived.cpp: In member function ‘virtual int MyClassDerived::qt_metacall(QMetaObject::Call, int, void**)’:
moc_myclassderived.cpp:70: error: invalid use of incomplete type ‘struct MyClassDerivedPrivate’
myclassderived.h:5: error: forward declaration of ‘struct MyClassDerivedPrivate’


Это нормально, ведь moc ничего не знает о нашем Private классе, ведь он инклудид в себя только тот заголовочный файл, на основании которого он был сгенерированый. А в публичном заголовочном файле только forward объявление. Так как moc — это по сути добавка к нашей реализации, просто включим его в конец нашего .cpp файла:
..................
#include "moc_myclassderived.cpp"



Теперь запускаем сборку и… Опять та же ошибка!!! Не отчаивайтесь. Просто сделайте make distclean и соберите снова.
Ну вот вобщем и все… аааа конечно, пример использования. Тогда идем дальше.
Как и общела смотрим, что же нагенерил нам moc:
int MyClassDerived::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
  _id = MyClass::qt_metacall(_c, _id, _a);
  if (_id < 0)
    return _id;
  if (_c == QMetaObject::InvokeMetaMethod) {
    switch (_id) {
    case 0: signal2((*reinterpret_cast< int(*)>(_a[1]))); break;
    case 1: d_func()->_q_boo(); break;
    default: ;
    }
    _id -= 2;
  }
  return _id;
}


Обратите внимание: когда к нам приходит запрос на вызов слота с _id=1, то мы дергаем метод приватного класса напрямую, без никаких потерь, как будто эта система метавызовов является родной для приватного класса а не для публичногою (немного завираю, так как все таки небольшой оверхед есть в преобразовании типов, во время вызова функции d_func() ).

4. Давайте запустим таймер, чтоб он дернул наш метод при создании класса MyClassDerived через одну секунду.
В первую очередь объявим init() метод в MyClassDerivedPrivate.
Реализация в myclassderived.cpp выглядит таким образом:
void MyClassDerivedPrivate::init()
{
  Q_Q(MyClassDerived);
  QTimer::singleShot(1000,q,SLOT(_q_boo()));
}



Ну и добавим вызов инициализации в наш конструктор (раньше они у нас были пустые):
MyClassDerived::MyClassDerived(QObject *parent)
  :MyClass(*new MyClassDerivedPrivate(), parent)
{
 Q_D(MyClassDerived);
 d->init();

}

MyClassDerived::MyClassDerived(MyClassDerivedPrivate &dd, QObject * parent)
    :MyClass(dd, parent)
{
  Q_D(MyClassDerived);
  d->init();
}


Конечно в данном случае можно было не городить конструкцию с init(), просто бы в каждом конструкторе бы была такая запись:
 QTimer::singleShot(1000,this,SLOT(_q_boo()));

Но я хотел показать подход, когда в инициализации необходимо выполнить более чем одно действие.

Не поверите :-) Но это все. В следующем пункте покажу программку, которая это все оттестирует.

Тестируем наш код


Ну вот создаем новый проект (в моем случае я его сделал в подкаталоге main моего проекта habrahabra):
main.pro
TEMPLATE = app
LIBS += -lhabrhabr -L..
INCLUDEPATH += ../
TARGET = main

SOURCES += main.cpp


* This source code was highlighted with Source Code Highlighter.


ну и сам main.cpp:
#include "myclassderived.h"
#include <QApplication>

int main(int argc, char ** argv) {
  QApplication a(argc,argv);
  MyClassDerived d(0);
  return a.exec();
}


* This source code was highlighted with Source Code Highlighter.


Почему нужно было делать QApplication? Да потому как система сигналов и слотов не будет работать без цикла выполнения потока в контексте которого он будет выполнятся (в нашем случае mainloop'a).
Собираем, запускаем, получаем результат:
7
exit-code:1



Урааа!!! Все работает.

Заключение.


Может вас испугало что я так много написал по этой теме? В таком случае могу вас успокоить, все намного проще чем вам кажется. Просто я хотел показать как работает этот механизм, а не просто инструкции по применению вроде: «Вставтье это сюда и это сюда и ура у вас все работает». В действительности необходимо проделать всего три шага.
1. Объявить макрос Q_PRIVATE_SLOT(d_func(),_q_method());
2. Реализовать этот метод в приватном классе.
3. Добавить в конец cpp файла #include «moc_classname.cpp»

И все!!! Все просто.

Важно: я уже указывать порядок следования заголовочных файлов в статье касательно pimpl. Но тут напомню, что все приватные заголовочные файлы должны строго следовать за публичными и в списке HEADERS они должны идти в порядке включения. В нашем примере derived класс включает в себя заголовки базового класса, поэтому в списке HEADERS файла проекта он идет после заголовков родителя.
Ну и так же как и макросы d-указателя, макросы приватного слота не являются частью публичного API и могут быть изменены в любой момент. Но не пугайтесь, я успокаивал по этому поводу в статье по pimpl.

Как всегда приглашаю вас посетить мой блог: erudenko.com. Там можно почитать буржуйскую версию этой статьи и разные дополнения. Можно там писать коменты, буду отвечать по возможности.

Ну и по традиции исходники (исходники тестовой програмки полностью опубликованы выше, поэтому тут их не буду писать):
habrhabr.pro:
TEMPLATE = lib
HEADERS += myclass.h \
  myclass_p.h \
  myclassderived.h \
  myclassderived_p.h
SOURCES += myclass.cpp \
  myclassderived.cpp


* This source code was highlighted with Source Code Highlighter.


myclass.h
#ifndef MYCLASS_H
#define MYCLASS_H

#include <QObject>

class MyClassPrivate;
class MyClass : public QObject
{
Q_OBJECT
public:
  explicit MyClass(QObject *parent = 0);
  int foo() const;
signals:
  void signal(int);
protected:
  MyClassPrivate * const d_ptr;
  MyClass(MyClassPrivate &dd, QObject * parent);
private:
  Q_DECLARE_PRIVATE(MyClass);
};

#endif // MYCLASS_H


* This source code was highlighted with Source Code Highlighter.


myclass_p.h
#ifndef MYCLASS_P_H
#define MYCLASS_P_H
#include "myclass.h"

class MyClassPrivate
{
  Q_DECLARE_PUBLIC(MyClass);
public:
  MyClassPrivate();
  virtual ~MyClassPrivate();

  void foo();

  void _q_boo();

  int i;
  MyClass * q_ptr;
};

#endif // MYCLASS_P_H


* This source code was highlighted with Source Code Highlighter.


myclass.cpp
#include "myclass.h"
#include "myclass_p.h"
#include <QDebug>;
#include <QCoreApplication>;
MyClassPrivate::MyClassPrivate()
{
  i = 5;
}

MyClassPrivate::~MyClassPrivate()
{
  //nothing to do
}

void MyClassPrivate::foo()
{
  Q_Q(MyClass);
  emit(q->signal(i));
}

void MyClassPrivate::_q_boo()
{
  qDebug()<<i;
  QCoreApplication::exit(1);
}

MyClass::MyClass(QObject *parent)
  :QObject(parent)
  ,d_ptr(new MyClassPrivate())
{
  Q_D(MyClass);
  d->q_ptr = this;
}

MyClass::MyClass(MyClassPrivate &dd, QObject * parent)
  :QObject(parent)
  ,d_ptr(&dd)
{
  Q_D(MyClass);
  d->q_ptr = this;
}

int MyClass::foo() const
{
  Q_D(const MyClass);
  return d->i;
}


* This source code was highlighted with Source Code Highlighter.


myclassderived.h
#ifndef MYCLASSDERIVED_H
#define MYCLASSDERIVED_H
#include "myclass.h"

class MyClassDerivedPrivate;
class MyClassDerived : public MyClass
{
Q_OBJECT
public:
  explicit MyClassDerived(QObject *parent = 0);
signals:
  void signal2(int);
protected:
  MyClassDerived(MyClassDerivedPrivate &dd, QObject * parent);
private:
  Q_DECLARE_PRIVATE(MyClassDerived);
  Q_PRIVATE_SLOT(d_func(),void _q_boo());
};

#endif // MYCLASSDERIVED_H


* This source code was highlighted with Source Code Highlighter.


myclassderived_p.h
#ifndef MYCLASSDERIVED_P_H
#define MYCLASSDERIVED_P_H

#include "myclassderived.h"
#include "myclass_p.h"

class MyClassDerivedPrivate: public MyClassPrivate
{
  Q_DECLARE_PUBLIC(MyClassDerived);
public:
  MyClassDerivedPrivate();
  virtual ~MyClassDerivedPrivate();

  void foo2();
  void init();
  int j;
};

#endif // MYCLASSDERIVED_P_H


* This source code was highlighted with Source Code Highlighter.


myclassderived.cpp
#include "myclassderived.h"
#include "myclassderived_p.h"
#include <QTimer>;

MyClassDerivedPrivate::MyClassDerivedPrivate()
{
  j=6;
  i=7;
}

MyClassDerivedPrivate::~MyClassDerivedPrivate()
{

}

void MyClassDerivedPrivate::foo2()
{
  Q_Q(MyClassDerived);
  emit(q->signal2(j));
  emit(q->signal(j));
}

void MyClassDerivedPrivate::init()
{
  Q_Q(MyClassDerived);
  QTimer::singleShot(1000,q,SLOT(_q_boo()));
}

MyClassDerived::MyClassDerived(QObject *parent)
  :MyClass(*new MyClassDerivedPrivate(), parent)
{
 Q_D(MyClassDerived);
 d->init();

}

MyClassDerived::MyClassDerived(MyClassDerivedPrivate &dd, QObject * parent)
    :MyClass(dd, parent)
{
  Q_D(MyClassDerived);
  d->init();
}

#include "moc_myclassderived.cpp"


* This source code was highlighted with Source Code Highlighter.
Теги:
Хабы:
Всего голосов 28: ↑26 и ↓2 +24
Просмотры 6.8K
Комментарии 17
Комментарии Комментарии 17