Jesper K. Pedersen

CMake's AUTOMOC runs moc automatically but compiles all moc files together, causing extensive recompilation when touching any Q_OBJECT header. Including moc files in .cpp files reduced recompile time from 22 seconds to 5 seconds. This episode includes a script to automate this plus a git hook to ensure you always include moc files.

You can speed up Qt applications almost for free by adding a single define to enable QStringBuilder. The catch: your code may fail to compile or crash in some places, but clazy will warn about potential crashes and the compiler will catch errors.

Qt comes with lots of classes relating to strings these days, including QString, QStringView, QStringLiteral etc. It comes with so many that I lost track, so maybe it is time to call my good friend Peppe. In this episode we will discuss what you need to know to get it right at least 95% of the cases, without knowing it all.

In the previous two episodes we looked at Qt's support for rendering items in the model/view framework. In this episode we will turn our attention to custom delegates for editing items. In the KDAB gift shop we will receive a ready to use delegate for choosing items with a combo box.

In the previous episode, Jesper presented a new delegate super class, namely QWAMDelegate. In this episode, he demonstrates three use cases for delegates showing a “progress bar”, HTML, and an amount, an arrow and a percentage change.

QListView, QTableView and QTreeView can all be configured via a number of roles from the models, e.g. BackgroundRole, ForegroundRole, FontRole, and TextAlignmentRole. This often means that no additional configurations of the views are needed.

This episode completes the inline headers implementation by adding the required signal connections. It expands into class design discussion, showing how to create drop-in replacements for QTableView and QTreeView with row span support while avoiding code duplication through templated superclasses and private class inheritance.

This episode discusses runtime QVariant issues encountered during Qt 6 migration of an in-house tool. Topics include debugging QVariant problems, using QVariant::fromValue for solutions, issues with QVariant::toString(), the removal of QVariant operator<(), using QVariant::compare, and improved Money comparison in both Qt 5 and Qt 6.

This episode shows a specialized combo box for solving this simple problem:

Efficient software developers avoid repetitive tasks by using tools like Perl, Python, or Bash on source code outside their IDE. Qt Creator offers macro recording facilities that, combined with block commands, can handle many such tasks.

This episode explores C++'s explicit keyword: why there's no implicit keyword, why it's needed for QObjects, and available tooling. Topics include implicit conversions in string classes, when conversions go wrong, explicit to the rescue, named constructors, QObject-specific issues, Q_IMPLICIT, explicit(false), clang-tidy support, and rules for when implicit conversions are acceptable.

This episode completes the proxy model for reversing rows by handling the challenging layoutAboutToBeChanged signal. It covers understanding QModelIndex, updating persistent model indexes, layoutAboutToBeChanged and layoutChanged signals, and why persistent index updates differ for other operations like rowsInserted.

One of the most complex things in Qt's model/view framework is the implementation of proxy models.This episode shows an almost complete implementation of a proxy model which reverses its rows but, at the same time, also gives hints for where and when you can cut corners.

This episode introduces "git switch" and "git restore" -- two commands, which means that, in most cases, you do not need "git checkout" anymore.

Do you remember to add qAsConst around Qt containers when iterating? Without it, containers risk detaching just before iteration starts. This episode explains what qAsConst does, why and when it's needed, and how to handle iterating containers returned from function calls.

Jesper explores the smoothest way to implement operator<() for custom classes, journeying through std::tie() and std::tuple(), ending with a discussion on QString comparison considering human interpretation.

Your compiler likely parses nearly 100,000 lines of code for a simple Qt "Hello World!" program. This episode shows how to see exactly what code is given to the compiler for each source file you compile.

Using integers and strings for user IDs, project IDs, and names risks confusion between different types, with compilers unable to catch these errors. This episode shows a wrapper class to make these types unique and discusses Qt integration.

Developers with Java or C++98 backgrounds often default to subclassing when facing problems. Modern C++ offers many different solutions, and this episode demonstrates when subclassing isn't the right approach.

Designing API's is hard work with lots of traps. Even worse is the situation when you later maintain the code and just need a function to behave slightly different in different situations.