Основы разработки кроссплатформенных приложений на Qt C++

Введение в экосистему Qt: установка IDE, структура проекта и создание первого окна

Добро пожаловать в курс «Основы разработки кроссплатформенных приложений на Qt C++». Если вы здесь, значит, вы хотите научиться создавать мощные, красивые и быстрые приложения, которые работают везде: от Windows и macOS до Linux и встроенных систем в автомобилях.

Сегодня мы не просто напишем «Hello World». Мы разберем фундамент, на котором строится любое Qt-приложение, настроим профессиональный инструмент разработки и поймем, как этот «черный ящик» работает изнутри.

Что такое Qt и почему это круто?

Многие новички ошибочно называют Qt «библиотекой». Это не совсем верно. Qt — это фреймворк (каркас). Библиотека — это просто набор функций, который вы подключаете к своему коду. Фреймворк же диктует архитектуру вашего приложения и предоставляет инструменты для решения практически любых задач: от работы с сетью и базами данных до 3D-графики и воспроизведения мультимедиа.

Главная фишка Qt — кроссплатформенность. Вы пишете код один раз на C++, а затем просто компилируете его под разные операционные системы. Это экономит колоссальное количество времени и денег.

!Иллюстрация принципа «Напиши один раз — запускай везде», показывающая центральную роль Qt в разработке под разные платформы.

Шаг 1: Установка инструментов (Qt Creator)

Для комфортной работы нам понадобится Qt Creator. Это интегрированная среда разработки (IDE), созданная специально для Qt. Она умная, быстрая и содержит встроенный дизайнер интерфейсов.

Процесс установки:

Перейдите на официальный сайт Qt и найдите раздел загрузок для Open Source пользователей (если вы используете его для обучения). Вам понадобится Qt Online Installer.

Запустите установщик. Вам предложат войти в Qt Account (регистрация бесплатна и обязательна).

Самый важный момент — выбор компонентов.

В окне выбора компонентов у вас могут разбежаться глаза. Вот что вам нужно выбрать обязательно:

* Qt x.x.x (выберите последнюю стабильную версию, например, Qt 6.5 или 6.6). * Внутри ветки версии выберите компилятор для вашей ОС: * Для Windows: MinGW (если не хотите возиться с настройкой Visual Studio) или MSVC (если у вас уже стоит Visual Studio). * Для macOS: macOS. * Для Linux: Desktop gcc. * В разделе Developer and Designer Tools убедитесь, что отмечены Qt Creator и CMake.

> Совет: Не выбирайте «Android» или «Sources» (исходный код самого Qt), если вы только начинаете. Это сэкономит вам гигабайты трафика и места на диске.

Шаг 2: Создание первого проекта

После установки запустите Qt Creator. Нас встречает стартовый экран. Давайте создадим наше первое приложение.

Нажмите File (Файл) -> New Project (Новый проект).

Выберите Application (Qt) -> Qt Widgets Application. Это классический тип настольных приложений.

Назовите проект, например, MyFirstApp. Выберите папку для сохранения (желательно без кириллицы и пробелов в пути).

Система сборки: выберите CMake или qmake. CMake сейчас является стандартом индустрии, поэтому рекомендую привыкать к нему сразу.

В деталях класса (Class Information) оставьте всё по умолчанию:

* Class name: MainWindow * Base class: QMainWindow

На этапе выбора комплекта (Kit) выберите тот, который вы установили (например, Desktop Qt 6.x.x MinGW).

Нажмите Finish. Поздравляем, заготовка проекта создана!

Шаг 3: Анатомия проекта

Слева вы видите дерево файлов. Давайте разберем, за что отвечает каждый файл. Понимание этой структуры критически важно.

1. Файл проекта (CMakeLists.txt или .pro)

Это «рецепт» для сборки вашего приложения. Здесь указано, какие файлы компилировать и какие модули Qt подключить. Пока нам не нужно его трогать.

2. main.cpp — Точка входа

Это файл, с которого начинается выполнение программы. Давайте посмотрим на код:

Разберем каждую строку, так как это база:

* #include <QApplication>: Подключаем заголовочный файл класса QApplication. Этот класс управляет общесистемными настройками (шрифты, курсор, тема оформления). * QApplication a(argc, argv);: Создаем объект приложения a. В любой программе с графическим интерфейсом на Qt должен быть ровно один экземпляр QApplication. Он инициализирует графическую подсистему. * MainWindow w;: Создаем объект нашего главного окна. Пока оно создано только в памяти. * w.show();: Даем команду окну отобразиться на экране. * return a.exec();: Это самая интересная часть. Мы запускаем цикл событий (Event Loop).

[VISUALIZATION: Диаграмма цикла событий (Event Loop). Слева пользователь нажимает кнопку мыши. Стрелка ведет к блоку

Сердце Qt: мета-объектная система, механизм сигналов и слотов, управление памятью

В предыдущей статье мы создали наше первое окно и настроили среду разработки. Но чтобы писать действительно сложные и надежные приложения, недостаточно просто перетаскивать кнопки на форму. Нужно понимать, как Qt «дышит» и почему он считается чем-то большим, чем просто библиотека классов C++.

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

1. Мета-объектная система (MOC)

Стандартный C++ — это статически типизированный язык. Это означает, что после компиляции программа «забывает» многие детали о своих классах. В чистом C++ вы не можете просто так спросить у объекта: «Как называется твой класс?» или «Какие методы у тебя есть?», имея на руках только указатель void*.

Qt решает эту проблему, добавляя слой динамики поверх статического C++. Этот слой называется Meta-Object System.

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

В основе лежит специальная программа — Meta-Object Compiler (moc). Это не часть стандартного компилятора C++ (как GCC или MSVC), а отдельная утилита, поставляемая с Qt.

Процесс сборки выглядит так:

moc сканирует ваши заголовочные файлы (.h).

Если он находит класс, унаследованный от QObject и содержащий макрос Q_OBJECT, он генерирует дополнительный файл с исходным кодом C++ (обычно с именем moc_filename.cpp).

В этом сгенерированном файле содержится вся мета-информация: имя класса, список сигналов, слотов и свойств.

Затем обычный компилятор C++ компилирует и ваш код, и код, созданный moc, объединяя их в одну программу.

!Иллюстрация того, как MOC встраивается в стандартный процесс сборки C++ приложения.

Макрос Q_OBJECT

Вы часто будете видеть этот макрос в начале классов:

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

2. Сигналы и слоты: общение между объектами

Это, пожалуй, самая известная фишка Qt. Механизм сигналов и слотов позволяет объектам общаться друг с другом, ничего не зная друг о друге. Это реализация паттерна проектирования «Наблюдатель» (Observer), но возведенная в абсолют.

Проблема

Представьте, что у вас есть Кнопка и Окно. Вы хотите, чтобы при нажатии на кнопку окно закрывалось. В классическом программировании Кнопка должна была бы иметь указатель на Окно и вызывать его метод close(). Это создает жесткую связность (tight coupling). Кнопка перестает быть универсальной — она теперь зависит от Окна.

Решение Qt

* Сигнал (Signal): Это сообщение, которое объект «выкрикивает» в пространство, когда происходит какое-то событие (например, «меня нажали»). Объект не знает, кто его услышит и услышит ли вообще. * Слот (Slot): Это обычная функция, которая готова реагировать на сигнал.

Мы соединяем их с помощью метода QObject::connect.

Теперь Кнопка просто отправляет сигнал clicked. Ей все равно, кто на него подписан. Окно просто имеет слот close. Ему все равно, кто вызвал закрытие. Это слабая связность (loose coupling), и это прекрасно для архитектуры.

!Визуализация принципа слабой связности через сигналы и слоты.

Особенности механизма

Type-safe (Безопасность типов): Компилятор проверит, совпадают ли аргументы сигнала и слота. Вы не сможете передать строку в слот, ожидающий целое число.

Many-to-Many: Один сигнал можно подключить к нескольким слотам (сработают все). Несколько сигналов можно подключить к одному слоту.

Direct vs Queued: По умолчанию, если объекты в одном потоке, слот вызывается мгновенно (как обычная функция). Если в разных — событие ставится в очередь (это база для многопоточности в Qt).

Пример создания своих сигналов

В заголовочном файле:

В файле реализации (.cpp):

Ключевое слово emit не обязательно для компилятора (это пустой макрос), но его принято писать для читаемости кода, чтобы показать: «здесь улетает сигнал».

3. Объектная модель и управление памятью

C++ славится сложностью управления памятью. Забыл delete — получил утечку памяти. Удалил дважды — получил падение программы.

Qt упрощает эту задачу с помощью дерева объектов (Object Tree).

Родители и дети

Почти любой класс в Qt, наследуемый от QObject, может иметь «родителя» (parent). Когда вы создаете объект, вы можете передать указатель на родителя в конструктор.

Что это дает?

Визуальная иерархия: Если это виджеты, то кнопка отобразится внутри окна.

Управление памятью: Когда уничтожается родитель (window), он автоматически уничтожает всех своих детей (button).

Вам не нужно писать delete button. Достаточно написать delete window (или позволить ему удалиться автоматически при закрытии программы), и вся цепочка объектов очистится корректно.

!Иерархия владения объектами: удаление верхнего узла каскадно удаляет все нижние.

Важные правила памяти в Qt

* Стек vs Куча: Виджеты верхнего уровня (например, главное окно) часто создаются на стеке в main.cpp. Дочерние объекты (кнопки, поля ввода) всегда создаются в куче (через new), так как их жизненным циклом управляет родитель. * Умные указатели: В современном C++ принято использовать std::unique_ptr или std::shared_ptr. В Qt они тоже используются, но для наследников QObject встроенный механизм «родитель-ребенок» часто удобнее и предпочтительнее.

Резюме

Мы разобрали фундамент Qt:

MOC превращает C++ в динамический язык, позволяя использовать интроспекцию и генерацию кода.

Сигналы и слоты обеспечивают гибкую связь между компонентами без жестких зависимостей.

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

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

Конструирование интерфейса: базовые виджеты, менеджеры компоновки (Layouts) и стилизация

Добро пожаловать обратно. В прошлых лекциях мы научились создавать «скелет» приложения и заставили его «думать» с помощью сигналов и слотов. Теперь пришло время заняться внешним видом. Ведь каким бы гениальным ни был код внутри, пользователь встречает программу «по одежке».

Многие новички, переходящие с других языков (например, C# Windows Forms), привыкли расставлять кнопки по координатам: «Кнопка должна быть в точке X=100, Y=200». В мире кроссплатформенной разработки этот подход — смертный грех. Почему? Потому что на вашем мониторе это выглядит хорошо, а на ноутбуке с 4K-дисплеем или на Linux с другим системным шрифтом ваша кнопка уедет за край экрана или налезет на текст.

Сегодня мы научимся делать интерфейсы, которые «резиновые», адаптивные и красивые. Мы разберем базовые виджеты, систему компоновки (Layouts) и язык стилизации QSS.

Базовые кирпичики: Виджеты

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

Вот «джентльменский набор», который используется в 90% приложений:

* QLabel: Используется для отображения текста или изображений. Пользователь не может его редактировать. * QPushButton: Классическая кнопка, которая испускает сигнал clicked() при нажатии. * QLineEdit: Однострочное поле для ввода текста (логин, пароль). * QTextEdit / QPlainTextEdit: Многострочное поле для ввода больших текстов. * QCheckBox: Галочка (флажок) для выбора опций (вкл/выкл). * QComboBox: Выпадающий список для выбора одного варианта из многих.

Создание виджета в коде выглядит просто:

Чтобы кнопка появилась на экране, её нужно либо добавить в иерархию (указать родителя), либо, что гораздо правильнее, поместить в Layout.

Философия Layouts (Менеджеры компоновки)

Менеджер компоновки — это невидимый объект, который управляет размером и положением виджетов внутри родительского окна. Вместо того чтобы задавать координаты, вы говорите: «Поставь эти три кнопки вертикально в ряд». Layout сам посчитает координаты, отступы и размеры.

!Схема работы трех основных менеджеров компоновки: вертикального, горизонтального и сеточного.

Основные классы компоновки

QVBoxLayout (Vertical): Выстраивает виджеты сверху вниз.

QHBoxLayout (Horizontal): Выстраивает виджеты слева направо.

QGridLayout: Размещает виджеты в ячейках сетки (строка, столбец).

Как рассчитывается геометрия?

Когда Layout распределяет место, он учитывает несколько параметров. Давайте представим это в виде формулы расчета ширины, которую занимает виджет внутри контейнера:

Где: * — итоговая ширина, занимаемая элементом в пространстве компоновки. * — ширина самого виджета (контента). * — внутренние отступы (Padding) внутри виджета. * — внешние отступы (Margin) между виджетом и соседями.

Layout автоматически пытается минимизировать и максимизировать , если политика размера виджета (Size Policy) позволяет ему растягиваться.

Практика: Создаем форму входа

Давайте напишем код, который создает классическое окно логина, используя вложенные компоновки. Мы не будем использовать визуальный дизайнер, чтобы понять логику кода.

Представьте структуру:

Вертикальный список (основной).

Внутри него: Поле логина, Поле пароля.

Внизу: Горизонтальный ряд кнопок «Вход» и «Отмена».

Разбор полетов

Обратите внимание на метод addLayout. Мы вложили горизонтальную группу кнопок внутрь вертикального столба. Это ключевой принцип построения сложных интерфейсов в Qt: композиция простых лайаутов.

Если вы запустите этот код и начнете растягивать окно мышкой, поля ввода будут растягиваться, а кнопки останутся внизу. Это происходит благодаря Size Policy (политике размеров). По умолчанию QLineEdit старается занять всю доступную ширину, а QPushButton ведет себя скромнее.

Сетка: QGridLayout

Иногда вертикальных и горизонтальных списков недостаточно. Например, калькулятор. Там кнопки стоят ровными рядами. Для этого идеально подходит QGridLayout.

Последний метод addWidget принимает 4 аргумента координат: row (строка), column (столбец), rowSpan (сколько строк занимать), columnSpan (сколько столбцов занимать).

Стилизация: Qt Style Sheets (QSS)

Серые стандартные окна выглядят скучно. Qt позволяет менять внешний вид приложения с помощью механизма, почти идентичного CSS в веб-разработке. Это называется QSS.

Вы можете задать стиль для всего приложения (app.setStyleSheet) или для конкретного виджета.

Пример строки стиля:

Чтобы применить это в C++ коде:

Box Model (Блочная модель)

При стилизации важно понимать, как Qt считает размеры. Это описывается блочной моделью.

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

Формула полного размера элемента с учетом стилей выглядит так:

Где: * — полный размер элемента. * — размер полезного содержимого (например, текста на кнопке). * — Padding (внутренний отступ). * — Border (толщина рамки). * — Margin (внешний отступ).

Если вы зададите фиксированную ширину виджету, но добавите огромный padding, виджет станет визуально больше, что может сломать верстку, если не учитывать это в Layout.

Советы профессионалов

Используйте SpacerItems (Пружины): В дизайнере или коде (QSpacerItem) они работают как невидимые пружины, расталкивая виджеты. Если хотите прижать кнопку к левому краю в QHBoxLayout, добавьте спейсер после кнопки.

Не задавайте жесткие размеры: Избегайте setFixedSize, если это не иконка. Используйте setMinimumSize или setMaximumSize, чтобы дать Layout свободу действий.

Разделяйте логику и стили: Не пишите QSS внутри C++ кода в кавычках (как в примере выше). Лучше вынесите стили в отдельный .qss файл, загружайте его при старте программы и применяйте ко всему QApplication. Так вы сможете менять тему оформления, не перекомпилируя программу.

Заключение

Теперь вы умеете не только создавать окна, но и грамотно размещать в них элементы, чтобы приложение выглядело профессионально на любой ОС. Мы изучили QVBoxLayout, QHBoxLayout, QGridLayout и основы QSS.

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

Работа с данными: архитектура Model/View, списки, таблицы и взаимодействие с файловой системой

В предыдущих статьях мы научились создавать интерфейс, размещать кнопки и обрабатывать нажатия. Но что, если нам нужно отобразить список из десяти тысяч товаров? Или таблицу с данными из базы данных? Использовать обычные виджеты вроде QListWidget или QTableWidget в таких случаях — плохая идея. Они хранят данные внутри себя, что приводит к дублированию и проблемам с производительностью.

Сегодня мы переходим на профессиональный уровень. Мы разберем архитектуру Model/View (Модель/Представление), которая является стандартом в Qt для работы с любыми наборами данных, а также научимся читать и сохранять эти данные в файлы.

Проблема стандартных виджетов

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

Это порождает две проблемы:

Дублирование памяти: Данные хранятся и в вашей структуре, и в виджете.

Синхронизация: Если фамилия сотрудника изменится в базе, вам нужно вручную искать соответствующий элемент в виджете и обновлять его.

Qt предлагает элегантное решение: разделить данные (Модель) и их отображение (Представление).

Архитектура Model/View

Эта архитектура разделяет работу с данными на три компонента:

Model (Модель): Отвечает за доступ к данным. Она ничего не знает о том, как эти данные будут выглядеть на экране. Она лишь отвечает на вопросы: «Сколько у нас строк?» и «Что лежит в строке 5?».

View (Представление): Отвечает за отображение. Это таблица или список, который мы видим. Представление не хранит данные, оно запрашивает их у модели.

Delegate (Делегат): Отвечает за отрисовку конкретной ячейки и её редактирование. Если вы хотите, чтобы вместо текста в ячейке был прогресс-бар или выпадающий список, вы настраиваете делегат.

!Диаграмма взаимодействия компонентов: Модель служит мостом между сырыми данными и Представлением.

Как они общаются?

Общение происходит через индексы (QModelIndex). Это временный «адрес» ячейки данных (строка, столбец, ссылка на родителя). Когда Представлению нужно нарисовать таблицу, оно спрашивает у Модели:

> «Дай мне данные для индекса (строка 0, столбец 1)».

Готовые решения: Файловая система

Прежде чем писать свою модель, давайте посмотрим на мощь встроенных классов. Qt предоставляет QFileSystemModel — готовую модель для работы с файловой системой.

Допустим, мы хотим написать свой Проводник. Раньше нам пришлось бы вручную сканировать папки. С Model/View это делается в несколько строк.

Обратите внимание: мы создали одну модель и подключили её к двум разным представлениям (QTreeView — дерево папок, QListView — список файлов). Если вы удалите файл через дерево, он мгновенно исчезнет и из списка. Это и есть магия единого источника истины.

Создание собственной модели

Чаще всего вам придется отображать свои собственные данные (структуры, классы). Для этого нужно наследоваться от абстрактных классов: * QAbstractListModel — для простых списков. * QAbstractTableModel — для таблиц.

Давайте создадим простую модель списка покупок. Для этого нужно переопределить всего два метода: rowCount (сколько строк) и data (что выводить).

Понятие Роли (Role)

Метод data() принимает не только индекс, но и роль (int role). Роль указывает, какой тип данных нужен представлению прямо сейчас.

Основные роли: * Qt::DisplayRole: Текст, который видит пользователь. * Qt::DecorationRole: Иконка или картинка слева от текста. * Qt::ToolTipRole: Всплывающая подсказка при наведении мыши. * Qt::BackgroundRole: Цвет фона ячейки.

Пример кода модели

Заголовочный файл ShoppingListModel.h:

Реализация ShoppingListModel.cpp:

Ключевые методы beginInsertRows и endInsertRows обязательны. Без них Представление не узнает, что размер модели изменился, и приложение может аварийно завершиться.

Математика индексов

Иногда при работе с таблицами нам нужно преобразовать двумерные координаты (строка, столбец) в линейный индекс массива, если данные хранятся в одномерном векторе. Формула для этого выглядит так:

где — искомый индекс в одномерном массиве, — номер строки (row), — общее количество столбцов (Columns) в таблице, а — номер текущего столбца (column).

Взаимодействие с файловой системой: QFile и QDir

Модель QFileSystemModel только показывает файлы. Чтобы их читать или создавать, используются классы QFile, QDir и потоки.

Работа с путями (QDir)

Класс QDir позволяет управлять путями, создавать папки и получать списки файлов.

Чтение и запись файлов (QFile)

QFile — это класс для ввода-вывода. Но сам по себе он работает с «сырыми» байтами. Для удобной работы с текстом его оборачивают в QTextStream.

Запись в файл:

Чтение из файла:

Бинарные файлы (QDataStream)

Если вам нужно сохранить сложные структуры данных (например, настройки или состояние игры), используйте QDataStream. Он гарантирует, что данные, записанные на Windows, корректно прочитаются на Linux, независимо от порядка байтов (endianness).

Резюме

Сегодня мы сделали большой шаг вперед:

Model/View позволяет отделять данные от интерфейса, что критически важно для масштабируемых приложений.

QFileSystemModel дает готовый инструмент для отображения файлов.

Собственные модели создаются через наследование QAbstractListModel или QAbstractTableModel с переопределением data() и rowCount().

QFile и QTextStream — основные инструменты для физического сохранения данных на диск.

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

Продвинутые техники: многопоточность, сетевое взаимодействие и деплой приложения

Поздравляю! Вы прошли долгий путь от создания первого окна до построения сложных архитектур Model/View. Ваше приложение уже умеет красиво выглядеть и работать с файлами. Но есть один нюанс: пока что оно «живет в вакууме» и работает в одном потоке.

Если вы попробуете загрузить большой файл или выполнить сложный математический расчет прямо в слоте нажатия кнопки, ваш интерфейс «замерзнет». Курсор превратится в колесико загрузки, и операционная система предложит «убить» программу. Это происходит потому, что вы блокируете главный поток (Main Thread).

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

1. Многопоточность: Как не заморозить интерфейс

В Qt, как и в большинстве UI-фреймворков, весь графический интерфейс рисуется и обновляется в одном потоке. Этот же поток обрабатывает события мыши и клавиатуры. Если вы занимаете этот поток долгой задачей (например, sleep(5) или сложный цикл), он перестает перерисовывать окно.

Решение 1: Worker-объекты и QThread

Многие новички совершают ошибку, наследуясь от QThread и переопределяя метод run(). В современном Qt (начиная с версии 4.4) рекомендованный подход — использование паттерна Worker.

!Визуализация паттерна Worker-Object и передачи данных через сигналы между потоками.

Алгоритм действий:

Создаем класс Worker, наследуемый от QObject. В нем пишем метод для тяжелой работы.

Создаем экземпляр QThread.

Создаем экземпляр Worker.

Используем метод worker->moveToThread(thread), чтобы «переселить» объект в другой поток.

Соединяем сигналы и слоты.

Решение 2: QtConcurrent

Если вам не нужно управлять жизненным циклом потока, а нужно просто «выстрелить и забыть» (например, применить фильтр к картинке), используйте высокоуровневый модуль QtConcurrent.

Теория эффективности: Закон Амдала

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

Где: * — ускорение выполнения программы (во сколько раз быстрее). — доля кода, которую можно* распараллелить (от 0 до 1). * — доля кода, которая выполняется строго последовательно (например, инициализация или обновление GUI). * — количество процессоров (потоков).

Даже если у вас 100 ядер (), но 10% программы () должно выполняться последовательно, максимальное ускорение никогда не превысит 10 раз.

2. Сетевое взаимодействие: Выходим в Интернет

Современное приложение бесполезно без сети. Qt предоставляет мощный модуль QtNetwork. Чтобы его использовать, добавьте в CMakeLists.txt:

QNetworkAccessManager (QNAM)

Центральный класс для работы с сетью — QNetworkAccessManager. Он работает асинхронно: вы отправляете запрос и «забываете» о нем, пока не придет сигнал finished.

!Схема асинхронного обмена данными между Qt-приложением и веб-сервером.

Пример получения курса валют (JSON) с сервера:

Работа с JSON

Qt имеет отличную встроенную поддержку JSON. Полученные байты можно легко превратить в объекты C++.

3. Деплой: «У меня работает, а у клиента — нет»

Вы скомпилировали проект, отправили .exe файл другу, а он пишет: «Ошибка, не найден Qt6Core.dll». Это классическая проблема зависимостей.

Qt-приложения по умолчанию используют динамическую линковку. Это значит, что код Qt не «вшит» в ваш exe-файл, а лежит рядом в виде библиотек (.dll на Windows, .so на Linux, .dylib на macOS).

Windows: windeployqt

Вам не нужно искать эти DLL вручную. Qt поставляется со специальной утилитой windeployqt.

Соберите проект в режиме Release.

Создайте пустую папку и скопируйте туда ваш .exe.

Откройте консоль Qt (не обычную CMD, а ту, что ставится с Qt).

Напишите: windeployqt.exe C:\Path\To\Your\App.exe

Утилита просканирует ваш файл, поймет, какие модули вы использовали (Network, Widgets, SVG), и скопирует все нужные DLL и плагины в папку.

Linux: AppImage

В Linux все сложнее из-за разнообразия дистрибутивов. Лучший современный способ — упаковать приложение в AppImage. Это один файл, который содержит в себе и вашу программу, и все библиотеки Qt. Для этого используется утилита linuxdeployqt.

macOS: macdeployqt

Аналогично Windows, утилита macdeployqt упаковывает библиотеки внутрь вашего .app бандла, делая его самодостаточным (Portable).

Заключение курса

Мы прошли большой путь. Теперь вы владеете полным стеком технологий Qt C++:

* Основы: IDE, структура проекта, компиляция. * Ядро: Сигналы, слоты, управление памятью. * UI: Виджеты, Layouts, стилизация QSS. * Данные: Model/View, файловая система. * Advanced: Многопоточность, Сеть, Деплой.

Qt — это огромная вселенная. Мы изучили лишь необходимые основы для старта. Дальше вас ждут QML (декларативный UI), работа с базами данных (Qt SQL), 3D-графика и многое другое. Но фундамент у вас уже есть. Удачи в разработке!