Every developer knows how frustrating it is when an application “forgets” everything on the next launch: window sizes, position on screen, selected options, and even recent documents. The user wastes time, trust drops, and the sense of quality disappears.
This chapter reveals how to turn variability into an ally. You’ll discover why professional Qt developers pay no less attention to settings than to business logic. Here the secret of stable user experience is revealed, working identically on Windows, Linux, and macOS—without hacks and platform surprises.
It covers 3 storage formats for settings, centralized access to configuration, and key grouping techniques that reduce code and errors. It shows how restoring interface state makes the application subjectively “faster” from the very first launch.
After this chapter, the “before/after” contrast becomes evident: instead of chaotic setValue()—predictable architecture, instead of random behavior—a controlled settings system.
Skip this material—and you’ll continue losing quality where it’s expected most.
This chapter includes ready-to-use code examples.
Chapter Self-Check
Why is it recommended to explicitly specify the format when creating a QSettings object in Qt6?Answer
Correct answer: Explicit format specification (IniFormat or JsonFormat) ensures identical application behavior on all platforms, since different formats are used by default: registry in Windows and INI files in UNIX systems.
What role does the QVariant class play when working with QSettings?Answer
Correct answer: QVariant allows storing and retrieving values of different types (bool, int, QString, QRect, etc.) through a unified interface, ensuring type safety during conversion via methods toString(), toInt(), toBool().
Why call the sync() method after setValue() in critical code locations?Answer
Correct answer: The sync() method forces all changes to be written to disk immediately, without waiting for automatic saving, which is critical in case of unexpected application termination or before important operations.
What happens if you don’t specify the second parameter (default value) in the value() method?Answer
Correct answer: If the key is absent, the method will return an empty QVariant, which when converted to a specific type will give the default value for that type (0 for int, false for bool, empty string for QString).
Why can beginGroup() and endGroup() methods be nested?Answer
Correct answer: Nesting allows creating hierarchical settings structure (e.g., /Settings/Colors/red), avoiding full path repetition and logically grouping related parameters.
What settings storage formats are available in Qt6 for cross-platform development?Answer
Correct answer: For cross-platform compatibility, QSettings::IniFormat (text INI files) and QSettings::JsonFormat (new Qt6 JSON-based format) are recommended, working identically on all platforms.
Why is the class destructor an appropriate place to save application settings?Answer
Correct answer: The destructor is guaranteed to be called when the object is destroyed, ensuring automatic saving of all current settings before closing the application without needing explicit save method calls.
How to avoid duplicating the full key path when working with multiple settings from one group?Answer
Correct answer: Using beginGroup() methods to set the prefix and endGroup() after finishing work with the group, allowing passing only the final parts of keys.
Why is not only the window size (width/height) saved in the example, but also its position (pos)?Answer
Correct answer: Saving position ensures complete window state restoration, making user experience consistent—the window appears where the user left it.
In what cases is it advisable to inherit QApplication and encapsulate a QSettings object in it?Answer
Correct answer: In large projects, this provides centralized settings access from any part of the code via static method, avoiding multiple QSettings object creation and initialization code duplication.
How do you check if settings were successfully saved to disk after calling setValue()?Answer
Correct answer: After calling sync(), check the status via the status() method—if it returns QSettings::NoError, the operation was successful, otherwise a write error occurred.
What advantage does the contains() method provide in Qt6 when working with settings?Answer
Correct answer: It allows explicitly checking key existence before reading, avoiding ambiguity when value() returns a default value—unclear if the key is absent or this is the actual saved value.
What happens if you create multiple QSettings objects with different formats for the same application?Answer
Correct answer: Each object will work with its own storage (e.g., one with INI file, another with JSON), which can lead to data desynchronization and debugging complications.
Practical Exercises
Easy Level
Application with Theme Memory
Create a simple Qt application with a text field and two buttons: “Light Theme” and “Dark Theme”. When clicking buttons, change the application’s color scheme (background and text color). Save the selected theme when closing the application and restore it on next launch. Also save and restore window dimensions.
Hints: Use QSettings::IniFormat for cross-platform compatibility. Save the theme index (0 or 1) using setValue(). In the constructor, call readSettings(), in the destructor—writeSettings(). For color changes, use QPalette, as shown in the chapter example with slotComboBoxActivated() method.
Medium Level
Text Editor with File History
Develop a text editor with a “File” menu containing “Open” and “Recent Files” items. When opening a file, add its path to the recent files list (maximum 5 files). Save this list via QSettings. On next launch, the “Recent Files” submenu should display paths to recently opened files. Also save the last edited text content, window position and size.
Hints: Use beginGroup(“/RecentFiles”) to organize keys. Store the path list as separate keys (/file1, /file2, etc.) or use QStringList. For dynamic menu creation, use QMenu::addAction() in a loop. When opening a file from the list, move it to first position. Use childKeys() to retrieve all saved files.
Hard Level
Multi-Profile Application with Settings Switching
Create an application with multiple user profiles. Each profile should have its own independent settings: color scheme, font size, window position/size, interface language (emulation—just display language code). Implement the ability to create a new profile, switch between profiles, and delete profiles. Inherit from QApplication for centralized settings management, as shown in listing 28.9. Also implement profile settings export to JSON format and import from it.
Hints: Use beginGroup() to create a separate group for each profile (e.g., /Profiles/Profile1). Store the list of profile names in a separate key. For export/import, create a temporary QSettings object with QSettings::JsonFormat and copy keys between objects via childKeys() and allKeys(). Use QFileDialog to select export/import file. Check status() after write operations. Create a ProfileManager class to encapsulate profile management logic.
💬 Join the Discussion!
Figured out QSettings and storage formats? Have questions about how to better organize settings in large projects?
Perhaps you’ve found interesting ways to migrate settings between application versions or encountered platform-specific behaviors?
Share your experience, ask questions, or help other readers master the Qt6 settings saving mechanism!