Qt creator примеры программ

Начну публиковать материалы по оконным приложениям на QT . Постараюсь быть последовательным, так чтобы можно было научиться, начиная с самого простого. Ориентироваться буду на среду разработки QT Creator . Библиотека QT изначально была ориентирована на язык программирования C++ , так что основной язык будет именно C++. Возможно в будущем я обращусь и к Python (PyQT), но по смотрим.

Создание приложения на C++ Qt

Не хочу обременять себя рассказом о среде QT Creator. Я думаю, что тот кто уже занимался программированием, легко начнет ориентироваться в программе. Как обычно в таких случаях начинаем с создания нового проекта ( New File or Project ). Далее выбираем тип приложения QT Widgets Application ( рисунок 1 ).

Дальнейшие шаги показаны на рисунках 2 — 5 . В частности на рисунке два показано окно выбора места расположения проекта и его название.

Рисунок 2. Выбор имени и расположения проекта
Рисунок 3. Выбор набора инструментов
Рисунок 5. Последнее окно мастера создания проектов

Запуск Qt приложений .exe вне Qt Creator

В результате приходим к следующей ситуации (см. рисунок 6 ).

Рисунок 6. Окно проекта

Т.е. мастер создания проектов построил некоторый начальный проект с возможностью визуального программирования. Но к визуальному программированию мы всегда можем обратиться. Мне лично интересно создавать приложение с нуля. Тогда можно разобраться в деталях. Поэтому в моих статьях об оконных приложениях в QT к визуальному программирования я обращаться не буду.

Поэтому предлагаю следующее. В консоли слева удалите элементы: mainwindow.h , mainwindow.cpp , mainwindow.ui . Кроме этого изменим main.cpp (см. рисунок 7 ).

Рисунок 7. Исходный код для нашего проекта

Пример оконного приложения на C++ Qt

И так на рисунке 7 мы имеем исходный вид нашего проекта. Именно из кода и будем далее исходить (танцевать от печки). Обращаю внимание на то, что кроме библиотеки QApplication мы подключаем библиотеку QtWidgets , которая как раз и необходима создания оконных приложений. Объект класса QApplication обязателен, так как он, в частности, обеспечивает обработку всех событий.

Ну, а далее, замените содержимое модуля main.cpp на текст из mainqt1.cpp . Программа подробно прокомментирована и, на мой взгляд, не требует дополнительных пояснений. Просто разберитесь в каждой строке, поменяйте отдельные параметры и вам все станет ясно. Единственно, что следовало бы добавить. В программе окно создается на основе библиотечного класса QFrame .

Этот класс является потомком класса QWidget . Так что можно без всяких проблем заменить в программе QFrame на QWidget .

Результат выполнения откомпилированной программы mainqt1.cpp представлен на рисунке 8 .

Рисунок 8. Результат работы программы mainqt1.cpp

Приложение, представленное в программе mainqt1.cpp страдает одним важным недостатком — в нем не указан механизм обработки событий. Ну, например, движение курсора мыши по полю окна или щелчок по label (ярлык). Здесь лучше всего создавать класс, наследующий от QFrame, и далее переопределять методы. Этим и другими интересными вещами мы займемся в следующих статьях.

Изучение Qt Creator | Урок #2 — Создание приложения на C++

Познакомьтесь с библиотекой QT, если вы еще не знакомы, программируйте на C++, подписывайтесь на мой канал Old Programmer . Вы забыли поставить ЛАЙК, не так ли?

Источник: dzen.ru

Начинаем программировать на Qt

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

• Hello Notepad
• Добавления кнопки выхода
• Наследование QWidget

• Создание файлов .pro

Hello Notepad

В первом примере, мы создадим простое окно для редактирования текста. Это самая элементарная программа с графическим интерфейсом Qt.

Исходный код примера:

#include int main(int argv, char **args)

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

В строке 6 создается объект класса QApplication, который управляет основными ресурсами, необходимыми для запуска любой программы с графическим интерфейсом Qt. Ему необходимо передать аргументы argv и args функции main() , т.к. Qt использует некоторые параметры командной строки, передаваемые при запуске программы.

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

В строке 9, окно редактирования текста выводится на экран в главном фрейме программы. Поскольку виджеты могут работать как контейнеры (В экземпляре класса QMainWindow находятся полосы панели инструментов, меню, строка состояния и несколько других виджетов), мы может отобразить только один виджет в окне нашей программы. По умолчанию, виджеты не видны. Функция show() используется для их отображения.

В строке 11, создается объект QApplication, который генерирует цикл событий в процессе работы приложения. События генерируются и передаются на обработку виджетам. Примерами событий могут являться клики мыши, нажатия клавиш на клавиатуре и т.п. Когда вы вводите текст в окне редактирования виджета QTextEdit, нажатия клавиш обрабатываются средствами виджета, и вводимый текст отображается в процессе набора.

Для запуска программы, откройте командную строку и зайдите в директорию с .cpp файлом программы. Выполните следующие команды shell-интерпретатора, чтобы скомпилировать пример.

После успешного выполнения предыдущих команд, скомпилированная программа будет размещена в директории текущего проекта (в Windows вы можете использовать nmake вместо make . Исполняемые файлы будут размещены в директориях debug или release, которые создадутся командой make . qmake — это утилита, которая создает файлы конфигурации Qt-проекта, если ей передан аргумент -project . После создания файла конфигурации (.pro), qmake генерирует Makefile, который используется утилитой make для сборки приложения. Позже, мы рассмотрим процесс написания собственных .pro файлов.

Добавления кнопки выхода

В реальных проектах, обычно используется более одного виджета. Сегодня мы добавим кнопку QPushButton под полем редактирования текста. При клике на нее, программа будет завершаться.

Рассмотрим исходный код программы.

int main(int argc, char **argv) < QApplication app(argc, argv); QTextEdit textEdit; QPushButton quitButton(«Quit»); /* 10 */ QObject::connect( /* 12 */ QVBoxLayout layout; /* 13 */ layout.addWidget( /* 14 */ layout.addWidget( QWidget window; /* 17 */ window.setLayout( window.show(); return app.exec(); >

Сначала подключается заголовочный файл QtGui. В нем содержатся все классы графического интерфейса Qt.

В строке 10 применяется механизм сигналов и слотов, для того, чтобы закрыть программу после нажатия на кнопку выхода. Слот — это функция, которая может быть вызвана в процессе выполнения программы. Сигнал — функция, вызывающая функции-слоты, которые с ним посредством QObject::connect.

quit() — слот класса QApplication, завершающий работу приложения. clicked() — сигнал, который передает нажатая кнопка QPushButton. Статическая функция QObject::connect связывает определенный слот и сигнал. SIGNAL() и SLOT() — макросы, которые принимают сигнатуры сигналов и слотов, для их связи между собой. Также, функции connect() необходимо передать указатели на объекты, которые будут принимать и рассылать сигналы.

В строке 12 создается объект класса QVBoxLayout. Как уже было сказано, виджеты могут содержать в себе другие виджеты. Можно задавать координаты и размер вложенных виджетов непосредственно, но обычно для этого используют слои (layouts). Слой управляет границами вложенных виджетов. Например, объект QVBoxLayout размещает виджеты в одну вертикальную колонку.

В строках 13 и 14, мы добавляем поле редактирования текста и кнопку выхода к слою layout . В строке 17 задается главный слой для всего приложения.

Наследование QWidget

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

Рассмотрим следующий код.

Макрос Q_OBJECT объявляет наш класс как QObject. Он должен находиться в самом начале определения класса. QObject добавляет несколько расширенных возможностей к обычному классу C++. Например, имена классов и слотов можно запросить в процессе выполнения. Также, мы можем узнать типы параметров слота и вызвать его.

В строке 13 объявляется слот quit() . В последствии, мы присоединим этот слот к сигналу.

В предыдущих примерах, создание графики и присоединение слотов осуществлялось внутри функции main() . Сейчас мы будем использовать конструктор Notepad.

addWidget(textEdit); layout->addWidget(quitButton); setLayout(layout); setWindowTitle(tr(«Notepad»)); >

Как видно из определения класса, мы используем указатели на объекты textEdit и quitButton . Для объектов QObject, почти всегда рациональнее выделять память в куче, вместо их копирования.

«Hello, World!» на Qt

Qt — это кросс-платформенный инструментарий разработки ПО на языке программирования C++. Есть также «привязки» ко многим другим языкам программирования: Python — PyQt, Ruby — QtRuby, Java — Qt Jambi, PHP — PHP-Qt и другие.
Позволяет запускать написанное с его помощью ПО в большинстве современных операционных систем путём простой компиляции программы для каждой ОС без изменения исходного кода. Включает в себя все основные классы, которые могут потребоваться при разработке прикладного программного обеспечения, начиная от элементов графического интерфейса и заканчивая классами для работы с сетью, базами данных и XML. Qt является полностью объектно-ориентированным, легко расширяемым и поддерживающим технику компонентного программирования.
В этой статье я покажу как написать простую программу «Hello, World!» с использованием библиотеки Qt4

Среда разработки

Сначала определимся со средой разработки. Лично я для написания программа использую кросс платформенную IDE Code::Blocks (подробнее про работу в этой IDE с Qt4 можно почитать тут). Так же есть плагины для работы с Qt в Eclipse. Коммерческая версия Qt под MS Windows может быть интегрирована в MSVS. Программы так же можно писать в любом текстовом редакторе, а потом компилировать их из командной строки.
Для наглядности, я покажу как компилировать программы, написанные на Qt, вручную.

Первая программа

Сначала в любом текстовом редакторе создадим файл и назовем его, например, main.cpp
Напишем в нем следующее:

1. #include
2. #include
3. int main( int argc, char * argv[])
4. QApplication app(argc, argv);
5. QDialog *dialog = new QDialog;
6. QLabel *label = new QLabel(dialog);
7. label->setText( «Hello, World!» );
8. dialog->show();
9. return app.exec();
10. >

В строках 1 и 2 мы подключили заголовочные файлы Qt в которых находятся основные классы.
В строке 4 мы объявили функцию main — главную функцию, с которой начинается выполнение любой программы. Она возвращает целое число (результат работы программы; 0 — если все в порядке) и принимает на вход две переменные — число параметров командной строки и массив, в котором они сохранены.
В строке 5 мы создаем объект приложения. Этому объекту мы передаем переменные командной строки.
В строке 6 мы создаем диалог — графическое окно прямоугольной формы, с заголовком и кнопками в верхнем правом углу. Создаем метку (строка 7). При создании метки мы передаем ее конструктору указатель на диалог, который становится ее родителем. При удалении родителя автоматически удаляются все его потомки, что очень удобно.

Затем устанавливаем надпись метки путем вызова функции setText() (строка 8). Как видно из примера, для отображаемого текста можно использовать html-теги.
В строке 9 мы отображаем наше диалоговое окно с меткой на экране.
И, наконец в строке 10 мы запускаем цикл обработки событий операционной системы приложением. Результат работы объекта мы возвращаем как результат работы программы.

Компиляция

Теперь скомпилируем написанную программу.
Перейдем в каталог, куда мы сохранили наш файл main.cpp и выполним команду

При этом произойдет создание заготовки проекта Qt4, в который автоматически будут включены все файлы исходных кодов, лежащих в данной директории. В результате получится файл с именем как у текущей директории и расширением .pro. Он будет выглядеть следующим образом:

TEMPLATE = app
TARGET =
DEPENDPATH += .
INCLUDEPATH += .

# Input
SOURCES += main.cpp

Как видим файл с исходными текстами добавился автоматически. Выполним команду

В результате мы получим Makefile, который используем для того что бы скомпилировать программу, выполнив следующую команду:

Подождем пока процесс компиляции не закончится и запустим нашу первую программу. Она будет выглядеть примерно так:

Вторая программа

Что бы получить полный контроль над создаваемыми окнами и другими виджетами, необходимо создавать производные от них классы. Создадим производный класс MyDialog. В качестве родительского будем использовать класс QDialog. Описание нашего класса поместим в заголовочный файл mydialog.h:

1. #include
2. #include
3. #include
4. #include
5. class MyDialog : public QDialog
6. Q_OBJECT
7. public :
8. MyDialog(QWidget *parent = 0);
9. >;

В первых четырех строках мы подключаем необходимые заголовочные файлы используемых графических элементов — диалога, кнопки, надписи и вертикального менеджера компоновки. Использовать такие крупные заголовочные файлы как , и др. в больших проектах не рекомендуется, так как это увеличивает время компиляции.
В шестой строке мы определили наш класс производным от QDialog.
На следующей строчке мы указали макрос Q_OBJECT, который указывает предпроцессору Qt что данный класс будет использовать дополнительные возможности Qt, например, систему сигналов и слотов.
На строке 9 мы указываем конструктор нашего диалогового окна. У него только один входной параметр — указатель на родительский объект (0 если родителя нет).
Конструктор нашего класса мы определим в файле mydialog.cpp:

1. #include «mydialog.h»
2. MyDialog::MyDialog(QWidget *parent) : QDialog(parent)
3. QVBoxLayout *layout = new QVBoxLayout( this );
4. QLabel *label = new QLabel( this );
5. label->setText( «Hello, World!» );
6. QPushButton *button = new QPushButton( this );
7. button->setText( «Close» );
8. layout->addWidget(label);
9. layout->addWidget(button);
10. connect(button, SIGNAL(clicked()), this , SLOT(close()));
11. >

В строке 4 мы создаем менеджер компоновки, который будет автоматически отображать все добавленные в него виджеты вертикально. Создание надписи аналогично предыдущему примеру.
В строках 7 и 8 создаем кнопку и устанавливаем ее текст. На следующих двух строчках мы добавляем наши виджеты в менеджер компоновки что бы он их автоматически упорядочил.
В строке 11 мы подключаем сигнал нажатия clicked() кнопки button к слоту close() нашего диалогового окна. У каждого объекта Qt могут быть свои сигналы и слоты, которые можно подключать к сигналам и слотам других объектов и таким образом осуществлять коммуникацию между элементами программы.
Файл main.cpp примет следующий вид:

1. #include
2. #include «mydialog.h»
3. int main( int argc, char * argv[])
4. QApplication app(argc, argv);
5. MyDialog *dialog = new MyDialog;
6. dialog->show();
7. return app.exec();
8. >

Пересоздаем проект командой

что бы новые файлы автоматически в него добавились и компилируем его. Вот так выглядит наша новая программа:

Третья программа

Если диалоговое окно содержит много графических элементов, то создавать такие окна довольно утомительно. Для упрощения этого процесса есть инструмент под названием Qt Designer. Запускаем его

и выбираем создание диалогового окна без кнопок. Добавляем на него метку и кнопку, редактируем их текст. С помощью инструмента редактора сигналов и слотов (Signal/Slot Editor) подключаем сигнал нажатия clicked() кнопки button к слоту close() диалогового окна. Располагаем их вертикально с помощью менеджера компоновки. Сохраняем полученный файл под именем mydialog.ui.

Позже он будет автоматически преобразован в заголовочный файл с именем ui_mydialog.h.
Изменяем заголовочный файл нашего диалогового окна mydialog.h следующим образом:

1. #include «ui_mydialog.h»
2. class MyDialog : public QDialog, public Ui::Dialog
3. Q_OBJECT
4. public :
5. MyDialog(QWidget *parent = 0);
6. >;

Все заголовочные файлы в нем заменяются на «ui_mydialog.h», а наследование становится множественным.
Конструктор значительно упрощается:

1. #include «mydialog.h»
2. MyDialog::MyDialog(QWidget *parent) : QDialog(parent)
3. setupUi( this );
4. >

Функция setupUi определена в заголовочном файле ui_mydialog.h и берет на себя всю рутину по созданию формы
Файл main.cpp по сравнению со второй программой не изменился.
Пересоздаем проект что бы новые файлы автоматически в него добавились и компилируем его.

Заключение

В этой статье было показаны базовые принципы программирования на С++ с использованием Qt4. Если хабрасообществу понравится данная публикация, то я продолжу цикл публикаций об использовании Qt4.

Источник: habr.com