Your cart is empty.
Keep shopping
Teach on Udemy
Turn what you know into an opportunity and reach millions around the world.
Learn MoreQt 5 Core Advanced with C++
Rating: 4.3 out of 54.3(762 ratings)
26,173 students
Qt 5 Core Advanced with C++
A followup to the Qt 5 Core for beginners and intermediate users.
Created byBryan Cairns
Last updated 12/2020
English
What you'll learn
- Qt 5
- Qt Core Advanced Classes
- Advanced C++ techniques
- Threading
- Concurrency
- Sockets
- TCP programming
- UDP programming
- Client / Server programming
- Thread Pools
- Multi-Threaded TCP server design
- SSL sockets
- Creating SSL certificates
- How to create libraries
- Creating dynamic and shared libraries
- Extending Qt with plugins
- Extending Qt applications with plugins
- Using MySQL
- Database plugins
- Inserting, deleting, and querying data in a database
- Testing database drivers
- Unit testing
- Qt Test Framework
- Data driven testing
- Benchmarking
- Deploying applications on windows, mac and linux
- Static builds
- App Images
- Compressing application binaries
- Qt Installer Framework
Explore related topics
Course content
6 sections • 63 lectures • 12h 6m total length
- Exploring the current thread9:39
Explore how threads relate to processes and the cpu's cores, and how the os schedules threads for multithreaded execution. Inspect the current thread, thread sleep, and thread control.
- Versions - Qt 5 vs Qt 60:51
- Creating threads12:03
Demonstrates how to create and move objects to a separate thread in Qt, start timers, and manage threads with signals and slots and shared pointers.
- Inheriting QThread11:00
Learn why inheriting QThread is discouraged in Qt 5 core with C++, and adopt the move approach or runnable interfaces with signals and slots for safe threading.
- Thread lifecycle16:23
Explore multithreading in Qt by creating a counter on multiple threads managed by a thread manager, moving objects to threads, and coordinating with signals and slots, while avoiding common pitfalls.
- QThreadPool8:07
Explore the Qt thread pool design by implementing a runnable class, enabling auto-deleted tasks, thread reuse, and safe background execution within a Qt 5 core advanced C++ context.
- QMutex3:20
Understand the mutex concept and how it prevents race conditions. Explore how locking and unlocking enforce mutual exclusion, with non-recursive versus recursive mutex behavior.
- QMutexLocker13:45
Learn how a counter is safely updated across threads using a mutex and QMutexLocker in a Qt thread pool, and see the consequences of missing locks.
- QSemaphore11:13
Learn how semaphores generalize mutexes by allowing multiple acquisitions and controlled resources, then use a thread pool to queue work and acquire and release resources for each item.
- QWaitCondition22:02
Explore the wait condition and producer–consumer pattern in Qt 5 core with C++. Coordinate a buffer, mutex, and signals and slots to synchronize producer and consumer threads.
- Signals and slots in threads15:23
Explore signals and slots in threaded apps, comparing direct, queued, and auto connections, and learn to explicitly use a connection to route signals to the correct thread.
- Intro to QtConcurrent8:19
Explore QtConcurrent's high level APIs for asynchronous multithreading, using futures and blocking maps to map a function over a list and run tasks in parallel.
- QtConcurrent::run5:59
Explore using QtConcurrent::run to execute a test function on a thread pool, returning a future and showing the main thread and pool thread running asynchronously.
- QtConcurrent issues3:45
Explore a QtConcurrent issue in C++, a conversion pitfall when passing a name to a test function, and how an array initializer must be initialized as list or string literal.
- QFutureWatcher6:08
Explore using a future watcher with Qt 5 Core to run concurrent map operations on a list, multiply values, and wait for finished to observe results.
- QFuture getting values2:33
Learn how to extract values from QFuture using mapped futures, using const int, and leverage future watcher to run asynchronous operations in the background.
- QFutureWatcher Slots12:39
Explore how QFutureWatcher encapsulates futures with signals and slots to track lifecycle and per-item progress in an asynchronous map, enabling real-time updates in a graphical user interface.
- QFutureIterator8:09
Explore iterating over futures in Qt 5 core with C++, using Java-style future iterators, index-based loops, and for-each patterns; there's no single correct method, only preference.
- QFutureSynchronizer5:24
Learn how the QFutureSynchronizer coordinates multiple threads to simplify synchronization by adding tasks to a synchronizer and waiting for completion, avoiding a future watcher.
- Threaded example15:29
Build a command line interface that starts and stops multiple threads using a worker and a manager, with signals and slots and a background event loop.
- Section 1 - Assignment
- Section 1 - Quiz
- Networking Primer7:48
Explore how IP addresses, IPv4 and IPv6, and DNS queries enable internet communication from local loopback to global networks. Use nslookup and trace route to test and troubleshoot applications.
- QHostAddress9:27
Learn to enumerate all local IP addresses with Qt 5 using QHostAddress, QNetworkInterface, and AbstractSocket; distinguish IPv4/IPv6, loopback, and multicast within the OSI model.
- QUdpSocket17:45
Explore UDP networking in Qt through sending and receiving datagrams with QUdpSocket, binding to a port, and broadcasting data while contrasting UDP's connectionless model with TCP's connection-oriented approach.
- UDP Chat Example17:39
Explore a real-world UDP chat app in Qt 5 core C++. Run a command line interface and chat module on separate threads. Bind to a shared port and broadcast datagrams.
- QTcpSocket17:27
Examine how TCP sockets establish reliable connections via a three-way handshake, with abstract sockets, DNS lookups, and HTTP requests in a client–server model.
- QNetworkProxy8:41
Learn how to connect to and configure a proxy using QNetworkProxy, choosing per-socket or per-application scope, with http proxies and optional authenticators, and see how requests appear from the proxy.
- QSslSocket18:57
Secure a proxy connection with QSslSocket in Qt 5 Core Advanced with C++. Learn to read SSL certificates, enable start of encryption, and wire signals and slots for pre-shared authentication.
- Synchronous TCP5:43
Demonstrates synchronous TCP in Qt 5 Core Advanced with C++, blocking the app while connecting to port 80, sending an HTTP request, and reading the full server response.
- Synchronous UDP12:22
Learn to implement synchronous udp communication by binding sockets with share address, broadcasting datagrams, and handling send and read cycles using a network datagram in Qt 5 core advanced.
- QNetworkAccessManager HTTP17:55
Learn to use QNetworkAccessManager to perform HTTP get and post requests, manage headers and mime types, and handle responses asynchronously with signals and slots.
- QNetworkAccessManager FTP21:32
Qt 5 core advanced with C++ network access manager for FTP file transfers, distinguishing POST from PUT, and implementing upload and download with signals, slots, and progress tracking.
- QTcpServer14:23
Explore how Qt's TCP server framework enables simple, event-driven networking: bind to a port, listen on any address, handle new connections, read data, and manage disconnections with signals and slots.
- Multi-threaded TCP Server21:55
Build a multi-threaded tcp server with a thread pool, handling each connection on a separate thread using Qt's QTcpServer, QTcpSocket, and QRunnable patterns, demonstrating http 1.1 responses.
- Multi-threaded TCP Server testing10:23
Master multi-threaded tcp server testing with siege to measure concurrency, throughput, and longest transactions, while understanding Linux ulimit limits and 255 concurrent connection caps.
- Ssl server - creating a certificate7:37
Learn to secure a tcp server with an ssl socket by creating a self-signed certificate using open ssl, including rsa key, certificate signing request, and a server certificate.
- Ssl server - creating the server18:46
Build a scaled ssl server in Qt by loading the server certificate and private key, handling incoming connections with ssl sockets, and returning an http-style hello world response.
- Ssl server testing5:20
Learn how to test an ssl connection using OpenSSL s_client on a local loopback, verify certificate chains, and understand self-signed certificates and browser warnings.
- Section 2 - Assignment
- Section 2 - Quiz
- Shared library17:59
describes how an executable uses preprocessing, compilation, and linking, then contrasts static and shared libraries for code reuse, including symbol export/import and runtime dependency considerations.
- Shared external library6:30
The lecture demonstrates code reuse by using an external library in a separate project, configuring include and depend paths, distributing headers, and addressing runtime library location on the operating system.
- Shared library dependencies7:17
Explains how shared libraries can depend on other libraries in a Qt 5 core advanced C++ project, illustrating a widget library that requires the network library and proper include paths.
- Static library7:21
Compare static libraries with shared libraries; a static lib bakes into the executable as a .a file, offering simpler deployment but larger binaries.
- Qt plugins23:34
Learn how Qt plugins work as shared libraries with a defined interface, differentiating high level and low level extensions, and implement a generic plugin factory to load them.
- Application plugins23:10
Declare a plugin interface and load it at runtime with Q plugin loader, handling library loading, unloading, and safe casting to the interface within a shared library.
- Using libraries from other authors5:19
Learn how to use a third-party library by rebuilding it, selecting release vs debug, and correctly include headers, set library paths, and link the proper library files.
- Overview of popular libraries1:56
Explore a universe of C++ libraries, including Boost and cute, from 3D graphics to real-time communications, and learn to reuse third-party code instead of reinventing the wheel.
- Section 3 - Assignment
- Section 3 - Quiz
- Intro to databases13:09
Explore the relational database model by building tables, defining primary keys, and using SQL with phpMyAdmin and MySQL; create a users table and perform insert, select, and delete operations.
- QPluginLoader17:34
Explore loading and testing a Qt SQL plugin with QPluginLoader, resolving lib MySQL dependencies, and establishing a database connection using host, name, user, and password.
- QSqlDriver9:09
Explore the Qt 5 core QSqlDriver and its modular drivers like sqlite, mysql, odbc, and sql. Inspect features such as transactions, query size, blob, prepared queries, and last insert id.
- QSqlDatabase and QSqlQuery12:59
Use QSqlDatabase and QSqlQuery to connect to MySQL, query the Void Realms database's Users table, filter by age, iterate results with next, and handle errors.
- Data class example34:46
Build a data class in Qt 5 Core with begin, commit, rollback transactions, and open, load, save, remove, using insert/update logic with parameter binding.
- Section 4 - Assignment
- Section 4 - Quiz
- Qt Test8:13
Discover how to implement unit testing in Qt using Qt Test, with private slots, init and cleanup hooks, and signal spy to verify behavior and results.
- Basic tests7:45
Examine the Qt 5 core advanced with C++ test lifecycle in a basic setup, focusing on init test case, init cleanup, and private slots for per-test and shared resource management.
- Testing failure7:18
Explore how to design and run tests in a Qt 5 core advanced C++ context by creating a widget, using fail and verify macros, and validating age constraints.
- Data driven tests9:27
Explore data-driven tests in Qt 5 core with C++, using a data container for name and age, generating rows, and fetching values to validate age rules.
- Benchmarking6:09
Learn to benchmark code in a bare-bones Qt app, using a test main and benchmarking blocks to measure execution time, compare for versus for each, and report iterations.
- Skipping tests and expecting failure6:43
- Section 5 - Assignment
- Section 5 - Quiz
- Intro to deployment9:58
Explore how to deploy Qt applications by distinguishing debug and release builds, choosing kits, and understanding static versus shared linking, with platform-specific packaging considerations for Mac, Windows, and Linux.
- Deploying on Mac4:24
Qt 5 core advanced apps on macOS by creating a self-contained app bundle with frameworks, packaging into a DMG, and running from the terminal.
- Deploy on Linux6:48
Deploy a Qt 5 core app on Linux using Linux Deploy and app image, wrapping dependencies into a self-contained binary for distribution across distros.
- Deploying on Windows7:21
- Static builds16:52
Explore the challenges and steps of static builds in Qt 5 core advanced with C++, including licensing caveats, building a self-contained executable, and optimizing size with upx.
- Qt installer framework5:28
Discover how the Qt installer framework supports Linux, macOS, and Windows, enabling highly customizable installers via a config and packages directory, XML files, seven zip archives, and a binary creator.
- Section 6 - Quiz
- Where to go from here1:53
Explore two distinct Qt technology paths after mastering core concepts: rapid UI scripting with Qt Quick for cross-platform interfaces and the desktop-oriented widgets approach, with beginner to advanced guidance.
Requirements
- Udemy course - Qt Core Beginners
- Udemy course - Qt Core Intermediate
Description
This is not a beginners course! This is a followup to the Udemy Qt 5 Core for beginners and intermediate users and picks up where they both left off. In this course you will learn how to work with threads, sockets, libraries, plugins, unit testing, and application deployment across multiple operating systems. This course overs Qt 5. Because Qt 6 has so many changes, I will re-record these lessons using Qt 6 and place them into a different course, check my instructor profile for updates.
Who this course is for:
- NOT FOR BEGINNERS - You have been warned!