Qt как создать свой сигнал

Сигналы и слоты в Qt

Сигналы и слоты используются для коммуникации между объектами. Механизм сигналов и слотов главная особенность Qt и вероятно та часть, которая отличаетcя от особенностей, предоставляемых другими фреймворками.

Введение

В программировании графического интерфейса, когда мы меняем один виджет, мы часто хотим что бы другой виджет получил об этом уведомление. В общем случае, мы хотим что бы объекты любого типа могла общаться с другими. Например, если пользователь нажимает кнопку Закрыть, мы вероятно хотим что бы была вызвана функция окна close().
Другие библиотеки добиваются такого рода общения используя обратный вызов. Обратный вызов это указатель на функцию, таким образом, если мы хотим что бы функция уведомила нас о каких-нибудь событиях, мы передаем указатель на другую функцию (обратновызываемую) этой функции. Функция в таком случае делает обратный вызов когда необходимо. Обратный вызов имеет два основных недостатка. Во-первых, он не является типобезопасным. Мы никогда не можем быть уверены что функция делает обратный вызов с корректными аргументами. Во-вторых, обратный вызов жестко связан с вызывающей его функцией, так как эта функция должна точно знать какой обратный вызов надо делать.

Сигналы и слоты

В Qt используется другая техника — сигналы и слоты. Сигнал вырабатывается когда происходит определенное событие. Слот это функция, которая вызывается в ответ на определенный сигнал. Виджеты Qt имеют много предопределенных сигналов и слотов, но мы всегда можем сделать дочерний класс и добавить наши сигналы и слоты в нем.

Механизм сигналов и слотов типобезопасен. Сигнатура сигнала должна совпадать с сигнатурой слота-получателя. (Фактически слот может иметь более короткую сигнатуру чем сигнал который он получает, так как он может игнорировать дополнительные аргументы). Так как сигнатуры сравнимы, компилятор может помочь нам обнаружить несовпадение типов. Сигналы и слоты слабо связаны. Класс, который вырабатывает сигнал не знает и не заботится о том, какие слоты его получат. Механизм сигналов и слотов Qt гарантирует, что если мы подключим сигнал к слоту, слот будет вызван с параметрами сигнала в нужное время. Сигналы и слоты могут принимать любое число аргументов любого типа. Они полностью типобезопасны.
Все классы, наследуемые от QObject или его дочерних классов (например, QWidget) могут содержать сигналы и слоты. Сигналы вырабатываются объектами когда они изменяют свое состояние так, что это может заинтересовать другие объекты. При этом он на знает и не заботится о том что у его сигнала может не быть получателя.
Слоты могут быть использованы для получения сигналов, но они так же нормальные функции-члены. Так же как объект не знает ничего о получателях своих сигналов, слот ничего не знает о сигналах, которые к нему подключены. Это гарантирует что полностью независимые компоненты могут быть созданы с помощью Qt.
Мы можем подключать к одному слоту столько сигналов, сколько захотим, также один сигнал может быть подключен к стольким слотам, сколько необходимо. Так же возможно подключать сигнал к другому сигналу (это вызовет выработку второго сигнала немедленно после появления первого).
Сигналы и слоты вместе составляют мощный механизм создания компонентов.

Небольшой пример

Описание класса на C++ может выглядеть вот так:

1. class Counter
3. public :
4. Counter()
5. int value () const
6. void setValue( int value );
7. private :
8. int m_value;
9. >;

Класс, наследуемый от QObject будет выглядеть следующим образом:

1. #include
2. class Counter : public QObject
4. Q_OBJECT
5. public :
6. Counter()
7. int value () const
8. public slots:
9. void setValue( int value );
10. signals:
11. void valueChanged( int newValue);
12. private :
13. int m_value;
14. >;

Класс, наследованный от QObject имеет то же самое внутреннее состояние и обеспечивает публичные методы для доступа к этому состоянию, но дополнительно у него есть поддержка для использования сигналов и слотов. Этот класс может сообщить внешнему миру что его состояние изменилось выработав сигнал valueChanged() и у него есть слот, в который другие объекты могут посылать сигналы.
Все классы, содержащие сигналы и слоты должны указывать макрос Q_OBJECT в начале их описания. Они также должны быть потомками (прямо или косвенно) QObject.
Слоты реализуются программистом. Возможная реализация слота Counter::setValue() выглядит следующим образом:

1. void Counter::setValue( int value )
3. if ( value != m_value)
4. m_value = value ;
5. emit valueChanged( value );
6. >
7. >

Ключевое слово emit вырабатывает сигнал valueChanged() объекта с новым значением в качестве аргумента.
В следующем примере мы создаем два объекта типа Counter и соединяем сигнал valueChanged() первого со слотом setValue() второго используя статическую функцию QObject::connect():

1. Counter a, b;
2. QObject::connect(&a, SIGNAL(valueChanged( int )),
3. &b, SLOT(setValue( int )));
4. a.setValue(12); // a.value() == 12, b.value() == 12
5. b.setValue(48); // a.value() == 12, b.value() == 48

Вызов a.setValue(12) вырабатывает сигнал valueChanged(12), который получит объект b в свой слот setValue() slot, т.е. будет вызвана функция b.setValue(12). Тогда b вырабатывает такой же сигнал valueChanged(), но так как он не подключен ни к одному слоту, это сигнал будет проигнорирован.
Отмечу что функция setValue() устанавливает новое значение и вырабатывает сигнал только есть value != m_value. Это предотвращает бесконечный цикл в случае кругового соединения (например, если бы b.valueChanged() был бы подключен к a.setValue()).
Сигнал вырабатывается для каждого соединения. Если соединение продублировать, два сигнала будут выработаны. Соединение всегда можно разорвать использовав функцию QObject::disconnect().
Приведенный выше пример показывает как объекты могут работать вместе без необходимости знать что-либо друг о друге. Что бы задействовать это, объекты должны быть соединены вместе и это может быть достигнуто простым вызовом функции QObject::connect() или с помощью свойства автоматического соединения программы uic.

Компилирование примера

Мета-объектный компилятор (meta-object compiler, moc) просматривает описание классов в файлах исходных кодов и генерирует код на C++, который инициализирует мета-объекты. Мета-объекты содержат имена все сигналов и слотов, так же как и указатели на эти функции.
Запуская программу moc для описания класса, содержащего сигналы и слоты, мы получаем файл исходных кодов, который должен быть скомпилирован и слинкован с другими объектными файлами приложения. При использовании qmake, правила для автоматического вызова moc будут добавлены в Makefile проекта.

Сигналы

Сигналы вырабатываются объектами когда они изменяют свое состояние так, что это может заинтересовать другие объекты. Только класс, который определяет сигнал или его потомки могут вырабатывать сигнал.
Когда сигнал вырабатывается, слот, к которому он подключен обычно выполняется немедленно, так же как и нормальный вызов процедуры. Когда это происходит, механизм сигналов и сигналов и слотов полностью независим от любого цикла событий графического интерфейса. Выполнение кода, следующего за выпуском сигнала произойдет сразу после выхода из всех слотов. Ситуация слегка отличается когда используются отложенные соединения (queued connections); в этом случае код после ключевого слова emit продолжает выполнение немедленно, а слоты будут выполнены позже.
Если несколько слотов подключены к одному сигналу, слоты будут выполнены один за другим в произвольном порядке после выработки сигнала.
Сигналы автоматически генерируются программой moc и не должны быть реализованы в исходном коде. Они могут не возвращать значение (т. е., используем тип void).
Замечание по поводу аргументов: опыт показывает, что сигналы и слоты легче повторно использовать при написании программ, если они не используют специальных типов. Например, если бы сигнал QScrollBar::valueChanged() использовал бы специальный тип вроде гипотетического QScrollBar::Range, он мог бы быть подключенным только к слотам, спроектированным специально для него.

Слоты

Слот вызывается когда вырабатывается сигнал, с которым он связан. Слот это обычная функция в C++ и может вызываться обычным способом; единственная его особенность, что с ним можно соединсять сигналы.
Так как слоты это нормальные функции-члены, они следуют обычным правилам C++ при прямом вызове. Тем не менее, как слоты, они могут быть вызваны любым компонентом, независимо от их уровней доступа, через соединение сигнал-слот. Это значит, что сигнал, выработаный объектом произвольного класса может вызвать защищенный (private) слот объекта несвязанного с ним класса.
Слоты так же можно объявлять виртуальными, что иногда бывает довольно удобно.
По сравнению с обратными вызовами, сигналы и слоты слегка медленнее из-за увеличенной гибкости, которую они обеспечивают, хотя разница для реальных приложений незаметна. В общем, выработка сигнала, который подключен к некоторым слотам, в среднем в 10 раз медленнее, чем вызов получателя напрямую, при вызове не виртуальной функции. Эти накладные расходы требуются для нахождения объекта, для безопасного перебора всех его соединений (т. е. проверка что последующий получатель не был уничтожен во время выпуска сигнала) и передачи любых параметров в общем виде. Хотя вызов десяти невиртуальных процедур может показаться дорогим, это менее затратно, чем, например, операция создания или удаления объекта. Пока мы создаем строку, вектор или список, что неявно требует создание объекта, затраты сигналов и слотов отвечают за очень маленькую долю в затратах среди всех вызовов процедур.
То же самое верно делаете ли вы системный вызов в слот или косвенно вызываете более десяти функций. На i586-500, мы можем вырабатывать около 2,000,000 сигналов в секунду, соединенных с одним слотом или 1,200,000 в секунду, при соединении в двумя слотами. Простота и гибкость механизма сигналов и слотов окупает дополнительные затраты, которые пользователь программы даже не заметит.
Следует заметить, что библиотеки, которые определяют переменные с именами signal или slot, могут вызывать предупреждения или ошибки компилятора при компиляции вместе с программой, написанной на Qt. Что бы решить данную проблему, необходимо убрать определение мешающегося символа препроцессора с помощью директивы #undef.

Метаобъектная информация

Метаобъект содержит дополнительную информацию, такую как имя объекта. Можно так же проверить наследует ли объект определенный класс, например:

1. if (widget->inherits( «QAbstractButton» ))
2. QAbstractButton *button = static_cast(widget);
3. button->toggle();
4. >

Метаобъектная информация также испльзуется qobject_cast(), который похож на QObject::inherits(), но менее предрасположен к ошибкам:

1. if (QAbstractButton *button = qobject_cast(widget))
2. button->toggle();

Реальный пример

Ниже приведен простой пример виджета с комментариями.

1. #ifndef LCDNUMBER_H
2. #define LCDNUMBER_H
3. #include
4. class LcdNumber : public QFrame
6. Q_OBJECT

Класс LcdNumber наследует QObject, который обладает большинством информации о сигналах и слотах через классы QFrame и QWidget. Он похож на встроенный виджет QLCDNumber.
Макрос Q_OBJECT указывает препроцессору объявить несколько функций-членов, которые будут реализованы программой moc; если при компилировании среди прочих будет появляется запись «undefined reference to vtable for LcdNumber», то скорее всего забыли запустить moc или добавить результат его работы в команду линковки.

1. public :
2. LcdNumber(QWidget *parent = 0);

Это не явно относится к moc’у, но если мы наследуем класс Qwidget, мы скорее всего захотим иметь аргумент parent (родитель) в конструкторе и передавать его конструктору родительского класса.
Некоторые деструкторы и функции-члены опущены здесь; moc игнорирует функции-члены.

1. signals:
2. void overflow();

LcdNumber вырабатывает сигнал когда его просят показать невозможное значение.
Если мы не заботимся о переполнении или знаем что оно не может произойти, мы может игнорировать этот сигнал, т.е. никуда его не подключать.
С другой стороны, если мы захотим вызвать две разные функции для реакции на эту ошибку, тогда просто подключаем эту функцию к двум разным слотам. Qt вызовет их оба (в произвольном порядке).

1. public slots:
2. void display( int num);
3. void display( double num);
4. void display( const QString &str);
5. void setHexMode();
6. void setDecMode();
7. void setOctMode();
8. void setBinMode();
9. void setSmallDecimalPoint( bool point);
10. >;
11. #endif

Слоты это функции, используемые для получения информации об изменениях состояний других виджетов. LcdNumber использует их, как показано в коде выше, для установки отображаемого числа. Так как функция display() часть интерфейса класса с остальной программой, этот слот публичный.
Стоит отметить что функция display() перегружена. Qt выберет подходящую версию при соединении сигнала и слота. С обратным вызовом нам бы пришлось искать пять разных имен и контролировать типы самостоятельно.
Некоторые незначительные функции-члены были опущены в данном примере.

Продвинутое использование сигналов и слотов

В некоторых случаях может потребоваться информация об отправителе сигнала. Qt предоставляет функцию Qobject::sender(), которая возвращает указатель на объект, пославший сигнал.
Класс QSignalMapper необходим в ситуациях, когда много сигналов подключены к одному и тому же слоту, и этот слот должен реагировать на каждый сигнал по-разному.
Предположим что у нас есть три кнопки, которые определяют, какой файл мы хотим открыть: «Tax File», «Accounts File», or «Report File».
Что бы открыть нужный файл мы соединяем их сигнал QPushButton::clicked() со слотом readFile(). Теперь используем функцию класса QSignalMapper — setMapping() — для преобразования всех сигналов в объект QSignalMapper.

1. signalMapper = new QSignalMapper( this );
2. signalMapper->setMapping(taxFileButton, QString( «taxfile.txt» ));
3. signalMapper->setMapping(accountFileButton, QString( «accountsfile.txt» ));
4. signalMapper->setMapping(reportFileButton, QString( «reportfile.txt» ));
5. connect(taxFileButton, SIGNAL(clicked()),
6. signalMapper, SLOT (map()));
7. connect(accountFileButton, SIGNAL(clicked()),
8. signalMapper, SLOT (map()));
9. connect(reportFileButton, SIGNAL(clicked()),
10. signalMapper, SLOT (map()));

Теперь подключаем сигнал mapped() к слоту readFile() в котором разные файлы будут открыты в зависимости от нажатой кнопки.

1. connect(signalMapper, SIGNAL(mapped( const QString &)),
2. this , SLOT(readFile( const QString &)));

Использование Qt со сторонними сигналами и слотами

Можно использовать Qt со сторонним механизмом сигналов и слотов. Можно использовать несколько механизмов в одном проекте. Для этого надо добавить следующую строку в файл проекта (.pro):

CONFIG += no_keywords

Эта опция говорит Qt не определять ключевые слова moc’a — signals, slots, и emit, так как эти имена будут использованы строронней библиотекой, например, Boost. Что бы использовать сигналы и слоты Qt с установленным флагом no_keywords, надо просто заменить все использования ключевых слов moc’а Qt в исходных файлах на соотствующие макросы — Q_SIGNALS, Q_SLOTS, и Q_EMIT.

2.2. Сигналы и слоты.

Сигналы и слоты являются одним из фундаментальных механизмов в Qt. Он позволяет наладить обмен информацией между объектами, которые ничего не знают друг о друге. Мы уже пробовали присоединять сигналы к слотам, объявляли свои собственные сигналы и слоты, выполняли реализацию своих слотов и посылали свои сигналы. Теперь рассмотрим этот механизм поближе. По своей природе, слоты очень близки к обычным функциям-членам в языке C++. Они могут быть виртуальными, они могут подвергаться перегрузке, они могут быть публичными, защищенными или приватными и они могут вызываться напрямую, как и обычные функции-члены. Отличие состоит в том, что слот может быть подключен к сигналу. В этом случае, функция-слот вызывается автоматически всякий раз, когда посылается сигнал. Объявление connect() выглядит следующим образом:

connect(sender, SIGNAL(signal), receiver, SLOT(slot));

Один сигнал может быть подключен к нескольким слотам:

connect(slider, SIGNAL(valueChanged(int)), spinBox, SLOT(setValue(int))); connect(slider, SIGNAL(valueChanged(int)), this, SLOT(updateStatusBarIndicator(int)));

Когда подается сигнал, то функции-слоты вызываются одна за другой, в порядке подключения.

connect(lcd, SIGNAL(overflow()), this, SLOT(handleMathError())); connect(calculator, SIGNAL(divisionByZero()), this, SLOT(handleMathError()));

Когда посылается какой-либо из сигналов — вызывается функция-слот.

connect(lineEdit, SIGNAL(textChanged(const QString &)), this, SIGNAL(updateRecord(const QString &)));

Когда посылается первый сигнал, то вслед за ним подается и второй. С точки зрения программы, соединение типа сигнал-сигнал ничем не отличается от соединения типа сигнал-слот.

disconnect(lcd, SIGNAL(overflow()), this, SLOT(handleMathError()));

Необходимость в этом возникает довольно редко, поскольку Qt сама автоматически разрывает соединение, если один из объектов уничтожается.

connect(ftp, SIGNAL(rawCommandReply(int, const QString &)), this, SLOT(processReply(int, const QString &)));

Исключение составляет случай, когда сигнал имеет большее число аргументов, чем слот. В этом случае «лишние» аргументы просто не передаются в слот.

Если типы входных аргументов не совместимы, или сигнал или слот не определены, Qt выдаст предупреждение во время исполнения. Точно так же Qt выдаст предупреждение, если в сигнатуры сигналов или слотов включены имена аргументов (в методе connect()).

Метаобъектная Система в библиотеке Qt

Одно из самых значительных достижений Qt — это расширение возможностей языка C++ механизмом создания независимых компонентов, которые могут взаимодействовать между собой, не имея информации друг о друге.

Этот механизм получил название Meta Object System и предоставляет два ключевых сервиса: сигналы-слоты и интроспекцию. Интроспекция позволяет получать метаинформацию о потомках класса QObject во время исполнения, включая список поддерживаемых сигналов, слотов и имя класса объекта. Этот механизм также реализует поддержку свойств объектов (используются в Qt Designer ) и перевод текста (для нужд интернационализации).

Стандарт C++ не обеспечивает возможность получения динамической метаинформации, которая необходима метаобъектной системе Qt. Поэтому данная проблема была решена созданием дополнительного инструмента moc (метаобъектный компилятор). Он собирает всю необходимую информацию из классов Q_OBJECT и делает ее доступной через вызовы обычных функций языка C++, что позволяет метаобъектной системе работать с любым компилятором C++.

Механизм работает следующим образом:

• Макрос Q_OBJECT объявляет ряд функций, который должны присутствовать в каждом потомке QObject: metaObject(), className(), tr() и ряд других.
• Утилита moc генерирует реализацию сигналов и функций, объявленных макросом Q_OBJECT.
• Эти функции используются методами connect() и disconnect().

Все действия выполняются автоматически, утилитами qmake и moc, так что вы довольно редко будете вспоминать об этом. Но если вас одолевает любопытство — загляните в исходные файлы, созданные moc, и посмотрите — что да как.

До сих пор мы использовали сигналы и слоты исключительно с виджетами. Однако, этот механизм реализован непосредственно в классе QObject и область его применения не ограничивается графическим интерфейсом. Он может использоваться любым классом, наследником QObject:

class Employee : public QObject < Q_OBJECT public: Employee() < mySalary = 0; >int salary() const < return mySalary; >public slots: void setSalary(int newSalary); signals: void salaryChanged(int newSalary); private: int mySalary; >; void Employee::setSalary(int newSalary) < if (newSalary != mySalary) < mySalary = newSalary; emit salaryChanged(mySalary); >>

Обратите внимание на реализацию слота setSalary(). Сигнал salaryChanged() посылается только в том случае, когда newSalary != mySalary. Такой способ предотвращает попадание в бесконечный цикл при наличии обратной связи с другим объектом.

Пред.	В начало	След.
Создание диалогов.	На уровень выше	Быстрая разработка диалогов.

Qt/C++ — Урок 024. Сигналы и слоты в Qt5

Сигналы и слоты используются для коммуникации между объектами в Qt. Механизм сигналов и слотов является центральной функцией в Qt, и вероятно это то, что отличает Qt по своему функционалу от других фреймворков. Сигналы и слоты стали возможны благодаря мета-объектной системе Qt.

Введение

При программировании GUI, когда изменяется один из виджетов, мы зачастую хотим, чтобы другие виджеты были об этом уведомлены. В общем случае, мы хотим, чтобы объекты могли взаимодействовать друг с другом. Например, если пользователь нажал кнопку Закрыть , мы вероятно захотим, чтобы объект window вызвал функцию close(). Другие инструменты разработки обеспечивают подобный функционал использованием callback. callback являет указателем на функцию, и если Вы хотите выполнить функцию, которая уведомит Вас о каком-либо событии, то Вы передаёте указатель на другую функцию, то есть callback. Работающая функция вызывает callback тогда, когда это уместно. В то время как существуют фреймворки, которые успешно используют callback функции, тем не менее callback являются неинтуитивным способом, который может вызывать проблемы с обеспечением корректности возвращаемых аргументов.

Сигналы и слоты

В Qt применяется альтернативная техника, то есть используются слоты и сигналы. Сигнал выполняется тогда, когда происходит определенное событие. Виджеты Qt имеют множество предопределённых сигналов, но мы можем всегда отнаследоваться отвиджета и определить собственные сигналы для них. Слотом является функция, которая вызывается в ответ на определенный сигнал. Виджеты Qt также имеют множество предопределенных слотов, но наследование от виджетов и добавление собственных слотов является обычной практикой, так что Вы можете обрабатывать те сигналы, которые Вам интересны. ] сигналы и слоты в Qt Сигналы и слоты являются типо-безопасным механизмом. Сигнатура сигнала должа совпадать с сигнатурой принимающего слота (Хотя фактически, слот может иметь сигнатуру короче, чем сигнал, но слот принимает сигнал, поскольку игнорирует лишние аргументы). Поскольку сигнатуры совместимы, то компилятор может помочь определить несоответствия при использовании синтаксиса основанного на указателях. Тогда как при синтаксисе, основанном на макросах SIGNAL и SLOT возможно определить несоответствие типов только в runtime процессе. Сигналы и слоты слабо связаны: класс, который вызывает сигнал знает только слот, который принимает сигнал. Механизм сигналов и слотов в Qt обеспечивается, если Вы подключили сигнал к слоту, который будет вызываться с параметрами сигнала в нужным момент. Сигналы и слоты могут иметь несколько аргументов и типов. И они являются полностью типо-безопасными. Все классы, которые отнаследованы от QObject или его подклассов (таких как QWidget) могут содержать сигналы и слоты. Сигналы вызываются объектами, которые изменяют своё состояние, что может быть интересно другим объектам. Это всё, что объект делает для коммуникации. И объект не беспокоится о том, кто принимает сигналы, которые он испускает. Это является честной инкапсуляцией информации, и обеспечивает то, что объект может использоваться, как программный компонент. Слоты могут быть использованы для приема сигналов, но они являются также и обычными функциями. Просто как объект не знает что приняло его сигнал, так и слот не знает, какой сигнал подключен к нему. Это обеспечивает реальную независимость компонентов, которые могут быть созданы с Qt. Вы можете подключить как множество сигналов к одному слоту, так и сигнал может быть подключен к множеству слотов. И даже возможно подключить сигнал непосредственно к другому сигналу. (Это вызовет второй сигнал, когда был вызван первый) Вместе, сигналы и слоты создают мощный механизм компонентного программирования.

Сигналы

Сигналы выпускаются объектом, когда его внутреннее состояние изменилось в определенном направлении, которое может быть интересно другим объектам. Сигналы являются публично доступными функциями и могут быть вызваны где угодно, но рекомендуется их вызывать только в классе, где они были определены, а также в его подклассах. Когда сигнал вызван, слот подключенный к нему обычно выполняется незамедлительно, просто как нормальная функция. Это возможно потому, что механизм сигналов и слотов является независимым от каких-либо циклов в GUI. Выполнение кода следует вызывать директивой emit , которая вызовет все слоты. В тех ситуациях, когда используются очереди подключений, код будет запускать сигнал, а слоты будут выполнены несколько позже. Если несколько слотов подключены к одному сигналу, то слоты будут вызваны один за другим, в том порядке, как они подключены, когда будет вызван сигнал. Сигналы автоматически генерируются в moc и не должны быть определены в .cpp файле, а также они никогда не возвращают результат. Примечание: По нашему опыту сигналы и слоты являются более используемыми, если они не используются специальных типов. Если QScrollBar::valueChanged () является специальным типом, таким как гипотетический QScrollBar::Range, он может подключаться только к слоту разработанному специально для QScrollBar . Подключение различных виджетов вместе может быть невозможным.

Слоты

Слот вызывается тогда, когда сигнал подключенный к нему был вызван. Слоты являются нормальной С++ функцией и может быть вызвана; они особенны только тем, что к ним подключаются сигналы. Также слоты могут выполняться как обычные функции, они подчиняются обычным правилам С++, когда вызываются непосредственно. Однако, как слоты, они могут быть вызваны другими компонентами, несмотря на их уровень доступа, через сигнал-слотовое подключение. Это означает, что сигнал испускается из одного из классов и может быть передан в приватный слот, который будет вызван из этого несвязанного класса. Вы можете также определить слоты как виртуальные, которые мы находим довольно полезными в практике. По сравнению с callback сигналы и слоты немного медленнее из-за той гибкости, что они предоставляют, хотя различия в реальном приложении незначительны. В основном, вызов сигнала, который подключается к нескольким слотам, приблизительно в десять раз медленнее, чем вызов не виртуальной функции. Это накладные расходы, из-за которых требуется находить объект соединения путём перебора всех слотов и сигналов и сравнения сигнатур для безопасного вызова функции-слота. В то время как десять невиртуальных функций вызываются меньшими накладными расходами, чем несколько операций new и delete. Как только вы выполняете строку, вектор или список операция за сценой, требующей операций new и delete, накладные расходы сигналов и слотов очень малы по сравнению с полной стоимостью вызова функции. Это верно, когда вы делаете системный вызов в слот или косвенно вызываете более, чем десять функций. Простота и гибкость механизма сигналов и слотов является неважными накладными расходами, которые ваши пользователи не заметят. Заметьте, что другие библиотеки определяют переменные, называемые сигналы и слоты и могут вызывать ошибки и предупреждения, когда компилируется приложение, основанное на Qt. Решение этих проблем применение директивы #undef для препроцессора.

Подключение сигнала к слоту

До пятой версии Qt подключение сигнала к слоту записывалось посредством макросов, тогда как в пятой версии стала применяться запись, основанная на указателях. Запись с макросами:

 
connect(button, SIGNAL(clicked()), this, SLOT(slotButton()));
Запись на основе указателей:
 
connect(button, &QPushButton::clicked, this, &MainWindow::slotButton);
Преимущество второго варианта заключается в том, что имеется возможность определить несоответствие сигнатур и неверное наименование слота или сигнала ещё на стадии компиляции проекта, а не в процессе тестирования приложения.
Пример использования сигналов и слотов
Для примера использования сигналов и слотов был создан проект, у которого в главном окне содержится три кнопки, к каждой из которых подключен слот, а уже эти слоты передают сигнал в один единый слот с номером нажатой кнопки.
Структура проекта

Структура проекта По сложившейся традиции ведения уроков прилагаю структуру проекта, которая абсолютно тривиальна и дефолтна до безобразия, что даже не буду описывать входящие в неё классы и файлы.
mainwindow.h
Итак, действо следующее: три кнопки - три слота, один сигнал на все три кнопки, который подаётся в слотах кнопок и передаёт номер кнопки в один общий слот, который выдаёт сообщение с номером кнопки.
 
#ifndef MAINWINDOW_H #define MAINWINDOW_H #include #include #include namespace Ui < class MainWindow; >class MainWindow : public QMainWindow < Q_OBJECT public: explicit MainWindow(QWidget *parent = 0); ~MainWindow(); signals: void signalFromButton(int buttonID); // Сигнал для передачи номер нажатой кнопки private: Ui::MainWindow *ui; private slots: void slotButton1(); // Слоты-обработчики нажатий кнопок void slotButton2(); void slotButton3(); // Слоты вызывающий сообщение с номеро нажатой кнопки void slotMessage(int buttonID); >; #endif // MAINWINDOW_H
mainwindow.cpp
А в этом файле настроена логика, описанная в предыдущих абзацах. Просто осмотрите программный код и переходите к просмотру видео, там подробно показан весь процесс, продемонстрировано приложение, а также показано, что будет, если произвести написание кода с различным ошибками.
 #include "mainwindow.h" #include "ui_mainwindow.h" MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow) < ui->setupUi(this); /* Объявляем и инициализируем кнопки * */ QPushButton *but_1 = new QPushButton(this); QPushButton *but_2 = new QPushButton(this); QPushButton *but_3 = new QPushButton(this); /* Устанавливаем номера кнопок * */ but_1->setText("1"); but_2->setText("2"); but_3->setText("3"); /* Добавляем кнопки на слой с вертикальной ориентацией * */ ui->verticalLayout->addWidget(but_1); ui->verticalLayout->addWidget(but_2); ui->verticalLayout->addWidget(but_3); /* Подключаем к кнопкам индивидуальные слоты * */ connect(but_1, SIGNAL(clicked()), this, SLOT(slotButton1())); connect(but_2, SIGNAL(clicked()), this, SLOT(slotButton2())); connect(but_3, SIGNAL(clicked()), this, SLOT(slotButton3())); /* Подключаем сигнал с передачей номера кнопки к слоту вывода сообщения * */ connect(this, &MainWindow::signalFromButton, this, &MainWindow::slotMessage); > MainWindow::~MainWindow() < delete ui; >/* Слоты для обработки нажатия кнопок * */ void MainWindow::slotButton1() < emit signalFromButton(1); >void MainWindow::slotButton2() < emit signalFromButton(2); >void MainWindow::slotButton3() < emit signalFromButton(3); >/* Слоты вывода сообщения * */ void MainWindow::slotMessage(int buttonID)
Видеоурок

Рекомендуем хостинг TIMEWEB
Стабильный хостинг, на котором располагается социальная сеть EVILEG. Для проектов на Django рекомендуем VDS хостинг.

QML - Урок 036. Работа с сигналами и слотами в QML
Qt/C++ - Урок 078. Не мешайте старый синтаксис сигналов на макросах SIGNAL SLOT и слотов с новым синтаксисом на указателях
Qt/C++ - Урок 076. Визуализация математических формул на Qt
Qt/C++ - Урок 075. Улучшение синтаксиса сигналов и слотов в Qt 5.7 и выше для перегруженных сигналов и слотов
QML - Урок 034. Передача структур данных из C++ слоя приложения в QML слой
Qt/C++ - Урок 073. Сигналы и слоты. Подключение слотов к перегруженным сигналам в рамках синтаксиса Qt5
SFML - Урок 001. Подключение библиотеки SFML в проект на Qt
PyQt5 - Урок 001. QLineEdit IP Address

По статье задано8 вопрос(ов) 
Подписка на обсуждение 5

Подписка на раздел 343
Вам это нравится? Поделитесь в социальных сетях!
Создание собственных виджетов Qt. Сигналы, слоты и события.
Когда я начинал изучать библиотеку Qt, весьма полезным показался пример виджета, выводящего бегущую строку. Подобный пример описан в настоящей статье, на нем мы разберем:

механизм сигналов и слотов Qt;
организацию объектов Qt в древовидную структуру, обеспечивающую автоматическое освобождение памяти при разрушении родительского объекта;
обработку событий в Qt.

В результате у нас получится создать свой собственный виджет и связать его со стандартными элементами управления.
Класс QObject
В библиотеке Qt есть множество самых различных классов, многие из них являются потомками класса QObject, который позволяет:

использовать механизм сигналов и слотов Qt;
организовывать объекты в древовидную структуру;
дополняет объект информацией о типе (мета-объектной информацией);
перемещать объект в отдельный поток [1];
обрабатывать события (QEvent);
использовать встроенный таймер QObject;

Механизм сигналов и слотов Qt
Механизм сигналов и слотов позволяет объектам обмениваться сообщениями. Например, при изменении текста внутри поля ввода (QLineEdit) генерируется сигнал textChanged, который может обработать любой другой объект, при этом его функция-обработчик называется слотом. Для того, чтобы при возникновении некоторого сигнала управление получил некоторый слот, достаточно соединить их функцией connect.
connect(speedSpinbox, SIGNAL(valueChanged(int)), runline, SLOT(setSpeed(int))); connect(textLine, SIGNAL(textChanged(QString)), runline, SLOT(setString(QString)));
В приведенном примере при генерацией сигнала valueChanged объекта speedSpinBox активируется слот setSpeed объекта runline.
Один сигнал может быть соединен сразу с несколькими слотами. Механизм сигналов и слотов позволяет общаться объектам, находящихся в различных потоках. Последним аргументом метода connect может быть тип соединения, позволяющий переключать асинхронную и синхронную обработку сигналов. По умолчанию используется соединение типа Qt::AutoConnection, означающее асинхронную обработку в случае если источник и обработчик сигнала находятся в одном потоке и синхронную (сигналы накапливаются в очереди потока), в противном случае. Для использования данного механизма в начале описания класса должен стоять макрос Q_OBJECT.
class RunLine : public QLabel < Q_OBJECT public: RunLine(QWidget *parent = 0); public slots: void setString(const QString string); void setSpeed(const int speed); protected: virtual void timerEvent(QTimerEvent*); int m_shift, m_timerId; QString m_string; >;
Из листинга видно, что наша бегущая строка имеет 2 слота, для изменения текста и скорости движения строки, но не генерирует ни одного сигнала.
Автоматическая сборка мусора в Qt
При использовании библиотеки Qt объекты часто формируют древовидную структуру с отношениями “родитель-потомок”. Для любого объекта можно назначить родителя вызовом метода setParent, получить список дочерних объектов методом children или, допустим, выполнять поиск среди дочерних объектов. Обычно родительский объект передается в качестве параметра конструктора дочернему объекту.
При уничтожении родительского объекта, рекурсивно удаляются все дочерние объекты. Иногда этот процесс называют автоматической сборкой мусора (т.к. память мы выделяем руками, а уничтожаются объекты сами).
В нашем примере создается главное окно (класс MainWidget ), которое включает в себя объекты классов QSpinBox , QLineEdit и RunLine . Очевидно, что вложенный QLineEdit не имеет смысла “оставлять живым” после того, как главное окно будет закрыто, т.е. время жизни поля ввода не больше чем время жизни главного окна, поэтому главное окно может быть родителем для вложенных в него объектов. Не всегда ситуация так очевидна, при установлении отношений “родитель-потомок” в Qt надо руководствоваться именно временем жизни объектов.
MainWidget::MainWidget(QWidget *parent) : QWidget(parent) < QGridLayout *layout(new QGridLayout(this)); QSpinBox *speedSpinbox(new QSpinBox(this)); QLineEdit *textLine(new QLineEdit(this)); RunLine *runline(new RunLine(this)); // . >

Методы findChild и findChildren позволяют находить среди дочерних объектов, такие, которые приводятся к требуемому типу и имеют заданное имя (имя может быть задано методом setObjectName ). Информация о типе и имени объекта называется мета-объектной.
Мета-объектная информация используется также, например при вызове функции qobject_cast , проверяющий принадлежность объекта к определенному типу.
Компилятор c++ ничего не знает об именах объектов (классы в c++ устроены проще), сигналах, слотах, событиях и т.п. В связи с этим, всякий раз, когда вы отправляете свою Qt-программу на компиляцию, сначала она подается на вход мета-объектного компилятора (MOC), который инициирует мета-объекты и генерирует код, понятный обычному компилятору.
Обработка событий в Qt
После работы с другими библиотеками, такими как WinAPI может быть трудно понять разницу между сигналом и событием, она кроется в источнике воздействия:

если мы нажимаем на кнопку, то кнопка обрабатывает соответствующее событие ( QKeyEvent/QMouseEvent,QTouchEvent , смотря чем нажали), при этом кнопка генерирует сигнал;
если мы провели мышью над окном, то элементы под мышью получали об этом событие QHoverEvent , кроме того, обрабатывалось событие QPaintEvent , т.к. область окна под мышью перерисовывалась.

Из этих примеров понятно, что сигнал должен генерируется объектом при изменении его внутреннего состояния, а событие всегда приходит из внешней среды. Источником события может быть указатель, колесико и кнопки мыши, кнопки клавиатуры, тачскрин, сетевой адаптер или, например, системный таймер.
При поступлении события в приложение, оно распространяется до тех пор, пока не будет обработано (если какой-либо объект обработал событие, он должен вызвать у него метод accept чтобы оно не распространялось дальше).
Например, мы щелкнули мышью над кнопкой спинбокса, при этом событие получает сначала MainWidget , но т.к. обработать он его не может, то передает его тому дочернему элементу, над которым был произведен щелчок (по спинбоксу), спинбокс передает событие кнопке, которая его обрабатывает и вызывает метод accept , генерируя сигнал clicked .
Пример отражает суть механизма обработки событий, однако, любое из промежуточных звеньев тоже могло обработать событие (при этом как выполнив для него accept , прервав обработку, так и передать событие обработанное дальше). Для реализации такого поведения может быть использован виртуальный метод event . Кроме того, объект может генерировать события методами sendEvent и postEvent .
Лично я считаю генерацию событий не правильным подходом. Возможно это стоит использовать в каких-то очень специфических ситуациях, когда невозможно использование сигналов и слотов (не видел таких ситуаций). Обработка нескольких видов событий, а также событий, предназначенных для других объектов в методе event превращает код в кашу и это не хорошо. Пользуйтесь событиями правильно.
Обработка событий таймера
В библиотеке Qt есть 3 вида таймера – встроенный в QObject, QTimer и QBasicTimer. Все эти таймеры по умолчанию запускаются в том потоке, в котором были созданы, т.е. они не могут сработать пока выполняется какой-либо другой код в текущем потоке, а значит, их точность зависит от загруженности и зернистости (granularity, трудоемкости функций) потока. Если вам нужна точность, таймер стоит перенести в отдельный поток.
Наиболее удобным из них является QTimer, именно его рекомендует использовать официальная документация – он с заданной периодичностью генерирует сигналы. Более подробное описание и пример использования QTimer можно найти в соседней статье [2].
QBasicTimer является низкоуровневым, периодическим (генерирует события до тех пор, пока не будет остановлен) таймером. Весь интерфейс таймера составляют 4 метода – isActive возвращает true если таймер работает, timerId возвращает идентификатор таймера (идентификатор нужен в том случае, если объект-обработчик принимает события от нескольких таймеров и должен их различать). Методы stop и start останавливают и запускают таймер соответственно. Метод start в качестве аргументов принимает период в миллисекундах, с которым должны генерироваться события и указатель на объект-обработчик событий, для которого должен быть перегружен метод timerEvent.
Интерфейс таймеров, встроенных в QObject очень поход на QBasicTimer. Они тоже являются периодическими и порождают события, а не сигналы. Запуск таймера осуществляется методом startTimer, который принимает периодичность и возвращает идентификатор таймера. Таймер работает и порождает события до тех пор, пока не будет уничтожен методом killTimer (принимающий идентификатор таймера в качестве аргумента).
Наша бегущая строка должна перемещаться через равные промежутки времени, для выполнения этого требования удобнее всего использовать таймер. Мы применим встроенный таймер для того, чтобы привести пример обработки событий в Qt.
void RunLine::timerEvent(QTimerEvent *) < const int length = m_string.length(); if(++m_shift >= length) m_shift = 0; setText(m_string.right(m_shift) + m_string.left(length - m_shift)); > void RunLine::setSpeed(const int speed) < if (m_timerId) killTimer(m_timerId); m_timerId = 0; if (speed < 0) return; if (speed) m_timerId = startTimer(1000/speed); >void RunLine::setString(const QString string)
Мы не используем объект QTimerEvent в методе timerEvent, т.к. у нас работает лишь один таймер (нам не требуется идентифицировать источник события). Скорость движения строки у нас задается методом setSpeed, однако мы могли избавить от этого метода при использовании внешнего QBasicTimer – достаточно было бы указать объект RunLine в качестве адресата событий.
Создание пользовательского интерфейса Qt
Класс QWidget является базовым для всех виджетов (элементов управления). Этот класс содержит множество полей и методов, например, методы изменения размера или перемещения объекта. Виджеты могут вкладываться друг в друга (визуально, а не с установкой отношения “родитель-потомок”, рассмотренного выше), при этом виджет-контейнер может использовать менеджер размещения (QLayout).
В листинге конструктора MainWidget представленного выше уже использовали менеджер QGridLayout, позволяющий размещать вложенные виджеты по сетке, кроме него может использоваться QVBoxLayout или QHBoxLayout (для размещения виджетов в линию по вертикали или горизонтали соответственно). Менеджер размещения управляет размерами и положением вложенных виджетов при изменении размера виджета-контейнера. Кроме того, менеджеры размещения могут вкладываться друг в друга. Размещать виджеты удобно визуально, мышью с использованием QtDesigner [2], но в этой статье мы вызываем addWidget явно. Во многих случаях явное использование addWidget оказывается единственным возможным, например если бы мы разрабатывали игру “Сапер” и размер игрового поля был бы заранее не известен.
layout->addWidget(textLine, 1, 1, 1, 1); layout->addWidget(speedSpinbox, 1, 2, 1, 1); layout->addWidget(runline, 2, 1, 1, 2);
Метод addWidget класса QGridLayout принимает в качестве второго и третьего аргумента координаты верхней левой ячейки таблицы, в которую требуется поместить виджет, указанный в первом аргументе. Последние два аргумента указывают количество ячеек по вертикали и горизонтали, которое займет данный виджет.
На приведенных выше листингах вы могли заметить, что класс бегущей строки наследует QLabel и вызывает его метод setText. Класс QLabel предназначен для вывода текста или изображений, является наследником класса QFrame. QLabel позволяет использовать HTML теги для оформления содержимого, однако, в текущей статье используется лишь метод setText() для задания выводимого текста.
Класс QFrame расширяет возможности QWidget в плане отображения рамки вокруг виджета и является базовым для элементов управления, нуждающихся в особой рамке. Наследниками класса QFrame являются, например, виджет панели инструментов (QToolBox), виджет видовой прокрутки (QAbstractScrollArea) или виджет вывода текста/изображений (QLabel).
Рекомендуемая литература:

Многопоточный сервер Qt. Пул потоков. Паттерн Decorator. Пример перемещения объекта в поток [Электронный ресурс] – режим доступа: https://pro-prof.com/archives/1390. Дата обращения: 06.05.2016.
Собственные виджеты в Qt Designer. Описание и пример использования QTimer [Электронный ресурс] – режим доступа: https://pro-prof.com/archives/958. Дата обращения: 06.05.2016.
Разработка игры “Сапер”. Пример использования QGridLayout [Электронный ресурс] – режим доступа: https://pro-prof.com/archives/887. Дата обращения: 06.05.2016.
Официальная документация по библиотеке Qt [Электронный ресурс] – режим доступа: https://doc.qt.io/. Дата обращения: 06.05.2016.
Библиотека Qt. Уроки [Электронный ресурс] – режим доступа: https://evileg.com/ru/. Дата обращения: 28.11.2019.



Похожие публикации:

Debian 11 как перезагрузить
Как нарисовать бмв м5 ф90
Как сделать локальный сайт доступным по сети
Почему у электробуса нет крыши