Qt 6 Core Intermediate with C++

Explore the changes from Qt 5, with many updates that mostly work; rely on the comprehensive documentation and built-in help to find details. The compatibility module collects deprecated items.

Install Qt 6 on Linux, Mac, and Windows with online installer, choosing only needed components and using maintenance tool for updates, licensing, open source obligations, and graphics engine OpenGL.

Porting from Qt 5 to Qt 6, this lecture highlights common roadblocks, the Qt five compatibility module, and changes in build systems such as CMake over qmake, and core APIs.

Qt offers a massive core with a graphical user interface, while the standard library lacks one; Qt under the hood uses parts of standard library, making portability and licensing crucial.

Learn when to use the C++ standard library in a Qt context, with insights that Qt relies on the standard library under the hood and Boost exists.

Evaluate if a component could migrate to another project; leave Qt out unless necessary. When using Qt, leverage its simplicity, ease, and power to unlock full potential.

Compare QMake and CMake, explain why Qt moves away from QMake and favors CMake as the industry standard, and show how developers can use both build systems.

Master the QObject base class, its signals and slots, and moc in Qt. Understand the event loop provided by QApplication and the object model.

Explore the Qt object macro and how moc uses it to generate signals and slots and meta type information. Learn the practical implications for building and debugging QObject-based classes.

Explore how Qt signals and slots enable inter-object communication, including defining signals, implementing slots, connecting sender and receiver, emitting alarm, and the difference between direct calls and event-driven connections.

Learn why a QObject cannot be copied, see how copying breaks signals and slots, and how q_disablecopy prevents copy construction, guiding you to use the object's address or a pointer.

Learn how memory splits into the stack and the heap. The stack auto-allocates and is limited; the heap requires manual management with new and delete via pointers.

Analyze how memory leaks arise when allocated memory is not released. Explore the impact on heap usage and system stability as leaks accumulate, even after processes end.

Explore dangling pointers in C++. Learn how heap-allocated objects on the stack can be accessed after destruction, causing crashes and unknown errors.

Explore smart pointers in Qt 6 core intermediate with C++, including unique_ptr, shared_ptr, weak_ptr, and auto_ptr, and learn how they prevent memory leaks and manage heap memory.

Explore the Qt object model and the parent-child relationship, illustrating how object trees manage memory by automatically deleting children when a parent is deleted.

Form a Qt object tree by assigning a child's parent, creating a parent-child relationship beyond memory management. Remember signals and slots are not auto connected.

Learn how Qt's QScopedPointer automatically deletes its object when it goes out of scope, demonstrated by a test class that tracks the object's lifecycle.

Explore QSharedPointer, a reference-counting smart pointer in Qt that transfers ownership between functions, tracks references, and auto deletes when the count reaches zero.

Share a smart pointer among multiple objects using Qt's QSharedPointer, swap and reset references with a vector of cats and a toy to manage lifetimes.

Explore QList, a template dynamic array in Qt 6 core. Learn to create lists, append, replace, remove (including remove all), slice, and query contains, index, size, and count.

QVector in Qt 6 Core is an alias for QList, making Vector identical under the hood. It explains the historical reason and avoids breaking changes.

Explore QSet, a templated container in Qt 6 that uses a hash table to store a set of values with unspecified order and blazing-fast lookups.

Explore how QMap uses key–value pairs to map string keys to integer values, insert and update entries, and perform fast key-based lookups with default handling for missing keys.

Explore QStringList, a powerful Qt string list extending QList<QString> with implicit sharing, fast index-based access, and built-in operations like replace, join, filter, contains, and read-only string view.

Explore qDeleteAll on a QList of QObjects, showing that pointers cannot be copied and delete all deletes items but does not remove them. Clear afterward to avoid dangling pointers.

Learn to manage Qt list items with QSharedPointer, wrapping list elements in smart pointers to enable automatic destruction and simpler memory management without manual cleanup.

Learn how to use qDeleteAll with QMap to safely delete QObject-derived values while preserving QString keys, manage object lifetimes, and avoid dangling pointers.

Learn to use QSharedPointer with a map by typedef-ing a complex template into a friendly alias for a map with string keys and QSharedPointer values.

Explore Qt 6 core concepts with view classes, including read-only views like the QString view, how view objects display data without owning it, and their relation to model-view-controller patterns.

This lecture demonstrates using QByteArrayView for fast, read-only access to data, contrasting it with QByteArray copies, and shows how to query size, data, slices, and index values.

Explore the QString view as a read-only, fast access into a QString that does not own the data, offering size, slicing, contains checks, and indexing with simple, loop-friendly apis.

Learn how QSettings persists application state across sessions by saving settings to storage and reloading them on startup, with a simple, platform independent API.

Explore how Qt's QSettings stores key-value pairs using QVariant, and learn to configure organization name, domain, and application name, plus save and load settings across platforms.

Learn how groups in QSettings prevent key conflicts by beginning and ending groups, assigning a group name and keys, and reading values from distinct groups like people and beer.

Navigate groups by beginning and ending group scopes, assign and read group-specific keys like people, beer, and test, then iterate, save to storage, and avoid key collisions.

Demonstrate how to set the QSettings filename from the application dir path, choose an Ironi format, and use begin group and end group to save and read settings with defaults.

Explore how file systems organize storage across HDDs, SSDs, and M-2 drives, explain partitions and volumes, and distinguish file formats, directories, and the role of extensions.

Explain the difference between disk, partition, and volume, define freespace, and show how partitions contain volumes with their file systems on physical drives.

Explore how folders function as logical containers for files within a file system, forming a folder tree and supporting permissions, compression, and encryption.

Explain how folders (directories) reside in the file system root, how files are data regions stored on the volume, and how folders can contain other folders and files.

Explore text and binary file types, explain how encodings like ASCII and UTF variants affect readability, and clarify that file extensions do not reliably reveal a file’s contents.

Clarifies how file extensions, mime types, and formats guide the operating system to open text files, mp3s, or encoded data in the appropriate application.

Explore the QIODevice base interface in Qt 6, then use QBuffer backed by a QByteArray to open, read, write, seek, flush, and close data with least privilege.

Write files in Qt 6 core intermediate with C++, using QFile to open in write-only mode, then write current date time and text via QByteArray in the current directory.

Explore appending files with append mode in Qt 6, adding data to the end without overwriting, and see how write-only, read-write, and append differ across platforms.

Learn how to read files in Qt 6 core with C++, using read-only mode and read all to fetch contents, and how to check file existence before opening.

Explore how to read large files efficiently by choosing between read lines and read chunks for plain text, using read-only mode, starting at the beginning, and looping until the end.

Explore how QTextStream, Qt's text stream, provides a simple interface for reading and writing text, with automatic encoding handling and options like UTF eight and UTF 16.

Use QDataStream to serialize binary data in Qt, encoding variables into a non readable file. Maintain the exact write order (age, name, weight) and version handling to ensure cross-version compatibility.

Explore how to navigate and manipulate directories with Qt 6 core, using QDir and QFileInfo to list, filter, create, rename, and delete with absolute and current paths.

Navigate a directory recursively with a self-calling list function that traverses folders and files, printing paths while filtering out dot entries, sorting by name, and noting recursion costs.

Explore QFileInfo by listing a temp path with QDir, iterating over the QFileInfoList to extract names, sizes, created and modified times, while noting permissions and potential crashes.

Explore how to use QStorageInfo in Qt 6 core to access operating system root and list mounted volumes with file system type, device, and storage metrics on Linux and Windows.

Learn to implement a file locking mechanism with QLockFile. Explore lock timing, auto unlock, and reporting process id, host, and application.

Intercept Qt messages in real time with a custom message handler and log them to a file using QTextStream, capturing date time, context, file, and line.

Create a static logger class for Qt 6 core that logs from anywhere by installing a static message handler and writes to a log file. Enable logging as needed.

Define a custom log test category with Qt logging category, enable or disable debug, info, warning, and critical levels, and simplify usage without macros.

Explore ASCII encoding, a seven-bit 128-character set of printable and non-printable characters, including carriage return and line feed, and its up-to-127 interchange with UTF eight for languages beyond English.

Explore UTF-8 as a variable-length Unicode encoding that supersedes ASCII, enabling the handling of multilingual text in Qt with QString and QChar, and demonstrate encoding, printing, and UTF-8 file I/O.

Explore UTF-16 and UTF-8 in Qt, comparing memory usage and encoding schemes. Learn how to switch a QTextStream from UTF-8 to UTF-16 and work with QString.

Explore base64 encoding as a universal binary-to-text scheme that protects data with special characters. Encode and decode in Qt using utf-8 to keep data safe for transmission.

Explore hex encoding in Qt 6 with C++, converting strings to hex and back using QByteArray and QString, and decoding to reveal binary data.