qt 配置文件读写操作总结 main

科学的发展-只不过是读大自然写的代码

已于 2024-09-26 11:36:35 修改

阅读量700

点赞数 19

分类专栏： # qt-配置文件文章标签： mysql 数据库

于 2024-09-26 11:15:10 首次发布

本文链接：https://blog.csdn.net/xie__jin__cheng/article/details/142548457

版权

qt-配置文件专栏收录该内容

20 篇文章 0 订阅

订阅专栏

1.概要

1.记忆要点

1.链接文件

// 指定配置文件的路径和INI格式

QSettings settings("path/to/myconfig.ini", QSettings::IniFormat);

2.读

// 读取设置

QString someSetting = settings.value("SomeKey", "DefaultValue").toString();

3.写

// 写入数据到配置文件中

settings.setValue("SomeKey", "SomeValue");

4.保存（不是必须系统也会自动保存）

// 同步到磁盘，确保数据被写入文件

settings.sync();

5.关于组

表现形式

[组名称X]

key=value

// 开始访问 [组名称X] 组
settings.beginGroup("组名称X");
QString theme = settings.value("Theme").toString();
settings.endGroup(); // 结束访问 [组名称X] 组

2.内容

1.Qt保存数据的方式有多少种

Qt提供了多种方式来保存和管理数据，这些方法适用于不同的场景和需求。以下是几种常见的Qt保存数据的方式：

1. 全局变量

尽管不推荐使用全局变量来保存全局数据，因为它可能导致代码难以维护和理解，但在非常小的项目中，这种方法可能是最简单的。

2. 使用qApp

Qt中的qApp是一个宏，指向当前的QApplication实例。可以通过从QApplication继承一个类，并在该类中保存全局变量，从而在任何地方访问这些数据。

3. QSettings

QSettings是一个跨平台的解决方案，用于读取和写入应用程序的配置数据。它可以将配置数据保存在操作系统的注册表（Windows）、配置文件（Unix-like），或者内存中。使用QSettings可以方便地保存和检索应用程序的配置设置。

4. JSON文件

使用Qt的JSON类和QJsonDocument类可以读取和写入JSON格式的配置文件。这种方法适用于有结构化数据的配置。

5. SQLite数据库

对于复杂的数据或者需要复杂查询和操作的情况，可以使用SQLite数据库来保存和管理配置数据。Qt通过QSqlDatabase和QSqlQuery类提供了对SQLite的支持。

6. 文本文件和数据文件

Qt提供了QFile类来支持对文本文件和数据文件的读写。结合使用QTextStream和QDataStream，可以方便地读写文本和二进制数据。

7. MySQL等数据库

除了SQLite外，Qt还支持连接到MySQL等其他类型的数据库，通过QSqlDatabase类来创建数据库连接，并使用QSqlQuery类来执行SQL语句，从而保存和管理数据。

8. 使用QWidget的用户自定义属性

Qt允许为QWidget或其子类添加自定义属性，这些属性可以用来存储各种类型的数据，包括整数。你可以使用QWidget::setProperty方法和QVariant类来设置和检索这些自定义属性。

9. 使用setData()和userData()

在Qt的GUI开发中，可以通过setData()和userData()接口来存储和获取数据。这些数据可以存储在界面元素中，用于在界面交互过程中使用。

10. 利用QVariant

QVariant是一个能够存储Qt中几乎所有数据类型的通用类型容器。它经常用于存储和传递复杂的数据类型，特别是在信号和槽机制中。

每种方法都有其适用场景，选择哪种方式取决于具体的需求和项目要求。在Qt中灵活使用这些方法来保存和管理数据，可以使程序更加高效、易于维护和扩展。

2.Qt数据持久化的方式有多少种

Qt数据持久化的方式多种多样，这些方法允许开发者将程序中的数据保存到外部存储介质中，以便在程序关闭或重启后仍然能够访问这些数据。以下是Qt数据持久化的几种常见方式：

1. 使用QSettings类

简介：QSettings是Qt提供的一个跨平台的配置文件读写工具，可以轻松地将应用程序的设置和其他数据存储在INI文件、注册表或XML文件中。
优势：跨平台、使用简单、支持多种存储格式。
示例：通过QSettings对象可以存储和读取应用程序的设置信息，如窗口大小、用户偏好等。

2. 文件操作（QFile + QTextStream/QDataStream）

简介：使用QFile类结合QTextStream或QDataStream进行文件读写操作，可以实现数据的文本或二进制格式存储。
优势：灵活性高，可以自定义数据格式。
示例：通过QFile打开文件，并使用QTextStream或QDataStream进行读写操作，适用于存储复杂数据结构或大量数据。

3. 使用数据库（如SQLite）

简介：对于需要频繁查询、更新和删除数据的应用程序，使用数据库进行数据持久化是一个很好的选择。Qt支持多种数据库，包括轻量级的SQLite。
优势：支持复杂的数据结构和查询操作，数据安全性好。
示例：通过QSqlDatabase建立数据库连接，使用QSqlQuery执行SQL语句进行数据的增删改查操作。

4. 使用序列化机制

简介：对于自定义的数据类型或复杂对象，可以通过序列化的方式将其转换为字节流，然后保存到文件中。Qt的QDataStream提供了基本的序列化支持，对于自定义类型，则需要重载<<和>>运算符。
优势：可以保存任意复杂对象，便于网络传输和跨平台共享。
示例：通过定义自定义数据类型的序列化方法，并使用QDataStream进行读写操作，实现复杂对象的持久化存储。

5. 使用全局变量或静态成员变量（不推荐）

简介：虽然全局变量或静态成员变量在程序运行期间始终存在，但它们并不属于真正的数据持久化方式，因为当程序关闭时，这些数据就会丢失。不过，在某些特殊情况下，它们可以被用作临时存储解决方案。
注意：这种方法通常不推荐用于数据持久化，因为它违反了封装和模块化的设计原则，且容易导致代码难以维护和理解。

总结

Qt数据持久化的方式多种多样，开发者可以根据应用程序的具体需求和场景选择合适的方法。在实际开发中，通常会结合使用多种数据持久化方式，以满足复杂的数据管理需求。例如，对于应用程序的设置信息，可以使用QSettings进行存储；对于需要频繁查询的大量数据，则可以使用数据库进行存储；而对于需要跨平台共享或网络传输的复杂对象，则可以使用序列化机制进行存储。

3.Qt将一个类持久化的方式有多少种

Qt将一个类持久化的方式主要有以下几种：

1. 使用QSettings类

简介：QSettings是Qt提供的跨平台配置文件读写工具，可以轻松地将应用程序的设置和其他数据存储在INI文件、注册表或XML文件中。虽然QSettings主要用于存储简单设置，但也可以用来保存类的某些属性或状态。
实现方式：通过为类的每个重要属性或状态设置一个唯一的键（key），然后使用QSettings的setValue和value方法来存储和读取这些值。
注意：QSettings更适合存储简单数据类型或类的少量重要属性，对于复杂的类或对象结构，可能需要其他方法。

2. 使用QFile和QDataStream（或QTextStream）

简介：通过QFile打开文件，然后使用QDataStream（对于二进制数据）或QTextStream（对于文本数据）将类的实例序列化为字节流或文本，并写入文件。当需要恢复类实例时，再从文件中读取数据并反序列化。
实现方式：
1. 重载类的<<和>>运算符，使其能够与QDataStream一起工作，从而支持类的序列化和反序列化。
2. 或者，使用QDataStream的writeBytesArray和readBytesArray等方法手动序列化类的关键部分。
注意：这种方法要求类及其成员变量支持序列化。对于包含指针或复杂数据结构的类，可能需要特殊的处理。

3. 使用数据库（如SQLite）

简介：将类的实例或关键属性存储在数据库中，利用数据库的强大功能来管理数据。
实现方式：
1. 定义与类对应的数据库表结构。
2. 使用QSqlDatabase和QSqlQuery等类来与数据库交互，存储和检索类的实例。
注意：这种方法适用于需要频繁查询、更新和删除数据的情况，且数据安全性要求较高。

4. 使用其他序列化库

简介：Qt本身提供了QDataStream等序列化工具，但也可以考虑使用第三方序列化库，如Boost.Serialization等，来提供更丰富的序列化和反序列化功能。
实现方式：根据所选序列化库的文档来实现类的序列化和反序列化。
注意：使用第三方库可能需要额外的依赖和配置工作。

5. 使用Qt的元对象系统（对于QObject派生类）

简介：Qt的元对象系统提供了动态对象属性（dynamic properties）的功能，允许在运行时为QObject派生类的对象添加属性。这些属性可以被保存和恢复。
实现方式：
1. 使用setProperty和property方法为类的实例添加和读取动态属性。
2. 结合使用QSettings或其他持久化机制来保存和恢复这些属性。
注意：这种方法适用于需要动态添加属性的场景，且属性类型需要是Qt元对象系统所支持的。

总结

Qt将一个类持久化的方式多种多样，选择哪种方式取决于类的特性、数据的需求以及应用程序的具体场景。在实际开发中，可以根据需要灵活选择一种或多种方法来实现类的持久化。

5.QSettings settings("MyCompany", "MyApplication");详解

QSettings 是 Qt 提供的一个用于读写应用程序设置的类。它支持跨平台工作，意味着在 Windows 上它会使用注册表来存储设置，而在 Unix-like 系统（如 Linux 和 macOS）上，它会使用基于文件的配置系统。

当你创建一个 QSettings 对象时，你需要指定两个参数：组织名称（organization name）和应用程序名称（application name）。这两个参数共同构成了一个“设置路径”，用于在存储系统中唯一标识你的应用程序的设置。

cpp复制代码

QSettings settings("MyCompany", "MyApplication");

在上面的代码中：

"MyCompany" 是组织名称。这通常是你或你的公司的名称，用于区分不同组织的应用程序。
"MyApplication" 是应用程序名称。这用于区分同一组织内的不同应用程序。

当你使用这两个参数创建 QSettings 对象后，你可以通过该对象来读写设置。例如：

settings.setValue("geometry", window->geometry());

这行代码将窗口的几何形状（位置、大小和状态）保存为名为 "geometry" 的设置项。下次应用程序启动时，你可以通过以下方式读取这个设置：

	`QRect rect = settings.value("geometry", QRect(100, 100, 400, 300)).toRect();`
	`window->setGeometry(rect);`

这里，value 方法尝试读取名为 "geometry" 的设置项。如果找不到该设置项，它将返回一个默认的 QRect 对象（在这个例子中是 (100, 100, 400, 300)）。然后，你可以使用这个默认的或读取到的值来设置窗口的几何形状。

QSettings 还支持其他类型的设置，如字符串、整数、布尔值等，并且你可以使用 setValue 和 value 方法的变体来读写这些类型的设置。

总的来说，QSettings 提供了一个简单而强大的机制来持久化应用程序的设置，使得这些设置能够在应用程序的不同运行会话之间保持不变。这对于创建具有用户友好界面的应用程序来说是非常重要的，因为它允许用户定制应用程序的行为，并且期望这些定制在下次使用应用程序时仍然有效。

6.QSettings的构造函数有多少种，分别都是什么

QSettings 类的构造函数提供了多种方式来构造对象，以便根据不同需求访问和修改应用程序的设置。以下是对 QSettings 构造函数的一个概述：

1. 基于组织和应用程序名称的构造函数

QSettings(const QString &organization, const QString &application = QString(), QObject *parent = nullptr);

组织（organization）：你的组织或公司名称，用于区分不同组织的应用程序设置。
应用程序（application）：你的应用程序名称，用于区分同一组织内的不同应用程序的设置。
父对象（parent）：可选参数，用于设置对象的父对象。

2. 指定存储格式和作用域的构造函数

QSettings(QSettings::Format format, QSettings::Scope scope, const QString &organization, const QString &application = QString(), QObject *parent = nullptr);

格式（format）：指定 QSettings 使用的存储格式，如 QSettings::NativeFormat（使用平台最合适的存储格式，如Windows注册表、macOS的CFPreferences等）或 QSettings::IniFormat（使用INI文件）。
作用域（scope）：指定设置是用户特定的还是由同一系统的所有用户共享的，如 QSettings::UserScope 或 QSettings::SystemScope。
组织（organization） 和 应用程序（application）：同上。
父对象（parent）：同上。

3. 基于文件名的构造函数

QSettings(const QString &fileName, QSettings::Format format, QObject *parent = nullptr);

文件名（fileName）：指定包含设置的文件的名称。如果文件不存在，则创建它。
格式（format）：同上，指定文件的存储格式。
父对象（parent）：同上。

4. 基于作用域的构造函数（较旧的API可能包含）

QSettings(QSettings::Scope scope, QObject *parent = nullptr);

作用域（scope）：同上。
父对象（parent）：同上。

注意：这个构造函数可能在一些较旧的Qt版本中存在，但在最新的Qt版本中可能不再推荐使用或已经废弃，因为它不提供组织和应用程序名称，可能导致设置路径不明确。

总结

`QSettings` 类的构造函数主要有三种类型，分别基于组织和应用程序名称、指定存储格式和作用域、以及基于文件名来构造对象。这些构造函数提供了灵活的方式来访问和修改应用程序的设置，以适应不同的平台和需求。在使用时，应根据实际情况选择合适的构造函数来构造 `QSettings` 对象。

7.QSettings的构造函数有多少种，分别都是什么，保存文件的位置和方式有什么不同

QSettings的构造函数提供了几种不同的方式来构造对象，以适应不同的使用场景和存储需求。以下是QSettings构造函数的几种常见形式及其保存文件的位置和方式的差异：

QSettings的构造函数

基于组织和应用程序名称的构造函数

QSettings(const QString &organization, const QString &application = QString(), QObject *parent = nullptr);
- 保存位置和方式：默认情况下，此构造函数使用操作系统特定的存储方式。在Windows上，设置通常保存在注册表中；在macOS上，保存在用户偏好设置中；在Linux和Unix系统上，可能会使用INI文件或系统特定的配置文件格式。用户无法直接指定保存文件的位置和名称。
指定存储格式和作用域的构造函数

QSettings(QSettings::Format format, QSettings::Scope scope, const QString &organization, const QString &application = QString(), QObject *parent = nullptr);
- 保存位置和方式：虽然此构造函数允许指定存储格式和作用域，但它仍然主要依赖于操作系统特定的存储机制。对于INI文件格式，如果操作系统支持且没有指定具体文件路径，Qt可能会在用户的主目录下的某个隐藏目录中创建或访问INI文件，但具体位置可能因Qt版本和操作系统而异。
基于文件名的构造函数

QSettings(const QString &fileName, QSettings::Format format, QObject *parent = nullptr);
- 保存位置和方式：此构造函数允许直接指定保存设置的文件名及其路径。文件将按照指定的格式（如INI）保存。这种方式为用户提供了最大的灵活性，可以精确控制设置文件的存储位置和内容格式。

保存文件的位置和方式的差异

基于组织和应用程序名称的构造函数：位置和方式由操作系统和Qt的默认行为决定，用户无法直接控制。这种方式适用于大多数标准应用场景，但可能不适用于需要精确控制设置文件存储位置的情况。
指定存储格式和作用域的构造函数：虽然提供了一定的灵活性，但仍然受到操作系统和Qt默认行为的影响。对于INI文件，如果没有指定具体文件路径，则保存位置可能因环境和配置而异。
基于文件名的构造函数：直接指定了文件名和路径，提供了最大的灵活性。用户可以根据需要选择任何有效的文件路径和格式来保存设置文件。这种方式特别适用于需要精确控制设置文件存储位置和内容格式的高级应用场景。

综上所述，QSettings的构造函数提供了不同的方式来构造对象并保存设置，用户可以根据实际需求选择合适的构造函数和存储方式。对于需要精确控制设置文件存储位置和内容格式的情况，推荐使用基于文件名的构造函数。

8.基于组织和应用程序名称的构造函数，文件保存的时候会保存到哪里

基于组织和应用程序名称的构造函数在创建QSettings对象时，文件保存的位置取决于操作系统以及是否指定了特定的存储格式。默认情况下，QSettings会使用操作系统特定的存储方式，而不是直接保存到一个文件中。但是，了解这些设置通常如何被存储是有帮助的。

文件保存位置

Windows

在Windows上，如果未指定存储格式（即使用默认的QSettings::NativeFormat），QSettings会将配置信息保存在注册表中。具体来说，这些信息通常保存在HKEY_CURRENT_USER\Software\[组织名称]\[应用程序名称]键下。这意味着不同的应用程序将有不同的注册表键来存储其配置信息。

macOS

在macOS上，默认情况下配置信息会被保存在用户的偏好设置中，这通常涉及到XML文件或Core Foundation的偏好设置API。文件的具体位置可能类似于$HOME/Library/Preferences/com.组织名称.应用程序名称.plist，但这不是通过直接文件访问实现的，而是通过macOS的偏好设置API。

Linux/Unix

在Linux和Unix系统上，如果没有指定特定的存储格式，QSettings可能会尝试使用INI文件或系统特定的配置文件格式。对于INI文件，默认位置可能会是用户的主目录下的某个隐藏目录，如$HOME/.config/组织名称/应用程序名称.ini，但这也取决于系统配置和Qt的安装方式。

指定存储格式

如果构造函数中指定了存储格式（如QSettings::IniFormat），并且没有提供文件名，那么QSettings可能会尝试在用户的主目录下的某个隐藏目录（如$HOME/.config或Windows上的用户特定位置）中创建或访问一个INI文件。然而，具体的文件名和路径可能会根据Qt的版本和操作系统的不同而有所差异。

结论

基于组织和应用程序名称的构造函数，文件保存的位置并不是直接指定的，而是由Qt根据操作系统的特性和是否指定了存储格式来决定的。在Windows上，配置信息通常保存在注册表中；在macOS上，保存在偏好设置中；在Linux和Unix系统上，可能会尝试使用INI文件或其他系统特定的配置文件格式。如果确实需要控制文件保存的具体位置，建议使用基于文件名的构造函数，并明确指定文件名和路径。

3.举例说明

1.基于文件名的构造函数举例

基于文件名的QSettings构造函数允许直接指定包含设置的文件的名称及其存储格式。这种方式为用户提供了最大的灵活性，可以精确控制设置文件的存储位置和内容格式。以下是该构造函数的一个示例：

#include <QCoreApplication>  
#include <QSettings>  
#include <QDebug>  
  
int main(int argc, char *argv[]) {  
    QCoreApplication a(argc, argv);  
  
    // 使用基于文件名的构造函数创建QSettings对象  
    // 第一个参数是设置文件的路径和名称，第二个参数指定文件的格式为INI格式  
    QSettings settings("路径/到/你的设置文件.ini", QSettings::IniFormat);  
  
    // 向设置文件中写入内容  
    settings.setValue("Section1/Key1", "Value1"); // 在"Section1"节下设置"Key1"的值为"Value1"  
    settings.setValue("Section2/Key2", 42);       // 在"Section2"节下设置"Key2"的值为整数42  
    // 注意：QSettings会自动处理不同类型的数据转换  
  
    // 读取设置文件中的值  
    QString value1 = settings.value("Section1/Key1", "默认值").toString(); // 读取"Section1/Key1"的值，如果不存在则返回"默认值"  
    int value2 = settings.value("Section2/Key2", 0).toInt();               // 读取"Section2/Key2"的值，如果不存在则返回0  
  
    // 输出读取到的值  
    qDebug() << "Section1/Key1:" << value1;  
    qDebug() << "Section2/Key2:" << value2;  
  
    return a.exec();  
}

在这个示例中，QSettings对象被构造为直接操作位于指定路径（"路径/到/你的设置文件.ini"）的INI格式文件。你可以通过setValue函数向文件中写入键值对，通过value函数读取文件中的值。如果尝试读取的键不存在，value函数将返回你指定的默认值（在示例中为"默认值"字符串和整数0）。

请注意，示例中的文件路径（"路径/到/你的设置文件.ini"）需要替换为你实际想要保存设置文件的路径和名称。此外，QSettings类能够自动处理多种数据类型的读写转换，如字符串、整数、浮点数等，这使得它成为Qt中处理应用程序设置的一个强大工具。

2.使用QFile和QDataStream（或QTextStream）序列化一个类举例

在Qt中，你可以使用QFile和QDataStream或QTextStream来序列化一个类。序列化是指将该类的对象的状态保存到某种存储介质（如文件）中，以便以后可以恢复该对象的状态。

下面是一个使用QFile和QDataStream序列化一个简单类的例子。假设你有一个类MyClass，它包含一些基本的数据成员。

MyClass 类的定义

#ifndef MYCLASS_H  
#define MYCLASS_H  
  
#include <QString>  
#include <QDataStream>  
  
class MyClass {  
public:  
    MyClass();  
    MyClass(const QString &name, int age);  
  
    QString getName() const;  
    void setName(const QString &name);  
  
    int getAge() const;  
    void setAge(int age);  
  
    // 为了使QDataStream能够序列化这个类，需要声明它为友元  
    friend QDataStream &operator<<(QDataStream &out, const MyClass &obj);  
    friend QDataStream &operator>>(QDataStream &in, MyClass &obj);  
  
private:  
    QString m_name;  
    int m_age;  
};  
  
#endif // MYCLASS_H

MyClass 类的实现

#include "MyClass.h"  
  
MyClass::MyClass() : m_name(), m_age(0) {}  
  
MyClass::MyClass(const QString &name, int age) : m_name(name), m_age(age) {}  
  
QString MyClass::getName() const {  
    return m_name;  
}  
  
void MyClass::setName(const QString &name) {  
    m_name = name;  
}  
  
int MyClass::getAge() const {  
    return m_age;  
}  
  
void MyClass::setAge(int age) {  
    m_age = age;  
}  
  
// 实现序列化操作符<<  
QDataStream &operator<<(QDataStream &out, const MyClass &obj) {  
    out << obj.m_name << obj.m_age;  
    return out;  
}  
  
// 实现反序列化操作符>>  
QDataStream &operator>>(QDataStream &in, MyClass &obj) {  
    QString name;  
    int age;  
    in >> name >> age;  
    obj.setName(name);  
    obj.setAge(age);  
    return in;  
}

使用QFile和QDataStream进行序列化和反序列化

#include <QCoreApplication>  
#include <QFile>  
#include <QDataStream>  
#include "MyClass.h"  
#include <QDebug>  
  
int main(int argc, char *argv[]) {  
    QCoreApplication a(argc, argv);  
  
    MyClass obj("John Doe", 30);  
  
    // 序列化对象到文件  
    QFile file("myclass.dat");  
    if (!file.open(QIODevice::WriteOnly)) {  
        qWarning() << "Could not open file for writing";  
        return -1;  
    }  
    QDataStream out(&file);  
    out << obj;  
    file.close();  
  
    // 从文件中反序列化对象  
    MyClass newObj;  
    if (!file.open(QIODevice::ReadOnly)) {  
        qWarning() << "Could not open file for reading";  
        return -1;  
    }  
    QDataStream in(&file);  
    in >> newObj;  
    file.close();  
  
    // 输出反序列化后的对象状态  
    qDebug() << "Name:" << newObj.getName();  
    qDebug() << "Age:" << newObj.getAge();  
  
    return a.exec();  
}

在这个例子中，我们首先定义了MyClass类，并实现了序列化（operator<<）和反序列化（operator>>）操作符。然后，在main函数中，我们创建了一个MyClass对象，并将其序列化到一个文件中。接着，我们从文件中读取数据，并使用反序列化操作符恢复了一个新的MyClass对象。最后，我们输出了新对象的状态以验证反序列化是否成功。

请注意，QDataStream序列化机制依赖于Qt的元对象系统（meta-object system），特别是对于自定义类型，需要确保它们是通过Q_DECLARE_METATYPE注册的，或者像上面例子中那样，通过实现序列化操作符来自定义序列化行为。不过，对于简单的由Qt基本类型（如QString, int等）组成的类，通常不需要额外的注册步骤。

运行结果

11:14:01: Debugging D:\projects\qts\untitled4\build\Desktop_Qt_6_7_2_MinGW_64_bit-Debug\untitled4.exe ...
Loaded settings: Name = "NewName" , Age = 30
Saved settings: Name = "NewName" , Age = 50
Reloaded settings: Name = "NewName" , Age = 50

3.使用Qt的元对象系统持久化一个类，简单举例

使用Qt的元对象系统来持久化一个类，通常涉及到利用QObject的动态属性（dynamic properties）功能以及QSettings或QFile等持久化机制。下面是一个简单的例子，展示如何使用Qt的元对象系统和QSettings来持久化一个自定义类的某些属性。

首先，我们定义一个简单的类，该类继承自QObject，并添加一些需要持久化的属性。

#include <QObject>  
#include <QSettings>  
#include <QString>  
#include <QDebug>  
  
class MyPersistentClass : public QObject  
{  
    Q_OBJECT  
    Q_PROPERTY(QString name READ name WRITE setName)  
    Q_PROPERTY(int age READ age WRITE setAge)  
  
public:  
    MyPersistentClass(QObject *parent = nullptr)  
        : QObject(parent), m_name("DefaultName"), m_age(0) {}  
  
    QString name() const { return m_name; }  
    void setName(const QString &name) { m_name = name; }  
  
    int age() const { return m_age; }  
    void setAge(int age) { m_age = age; }  
  
    void saveSettings() const  
    {  
        QSettings settings("MyCompany", "MyApplication");  
        settings.setValue("name", m_name);  
        settings.setValue("age", m_age);  
    }  
  
    void loadSettings()  
    {  
        QSettings settings("MyCompany", "MyApplication");  
        m_name = settings.value("name", "DefaultName").toString();  
        m_age = settings.value("age", 0).toInt();  
    }  
  
private:  
    QString m_name;  
    int m_age;  
};

在这个例子中，MyPersistentClass 有两个属性：name 和 age，它们都通过Q_PROPERTY宏声明为QObject的属性。这样，它们就可以被Qt的元对象系统所识别和处理。

类还提供了两个方法：saveSettings 和 loadSettings，用于将属性保存到QSettings中以及从QSettings中加载属性。QSettings是一个跨平台的配置文件读写工具，它将数据存储在操作系统的注册表（Windows）或配置文件（Unix-like系统）中。

使用这个方法，你可以这样来持久化和恢复类的实例：

#include <QCoreApplication>  
  
int main(int argc, char *argv[])  
{  
    QCoreApplication app(argc, argv);  
  
    MyPersistentClass obj;  
  
    // 加载设置  
    obj.loadSettings();  
    qDebug() << "Loaded settings: Name =" << obj.name() << ", Age =" << obj.age();  
  
    // 修改属性  
    obj.setName("NewName");  
    obj.setAge(30);  
  
    // 保存设置  
    obj.saveSettings();  
    qDebug() << "Saved settings: Name =" << obj.name() << ", Age =" << obj.age();  
  
    // 再次加载设置以验证保存是否成功  
    MyPersistentClass obj2;  
    obj2.loadSettings();  
    qDebug() << "Reloaded settings: Name =" << obj2.name() << ", Age =" << obj2.age();  
  
    return app.exec();  
}

在这个main函数中，我们创建了一个MyPersistentClass的实例，并先加载了它的设置。然后，我们修改了属性并保存了设置。最后，我们再次创建了一个新的实例，并加载了设置以验证保存是否成功。

请注意，这个例子中的QSettings使用了一个简单的键值对存储机制，并且假设应用程序的组织名称是"MyCompany"，应用程序的名称是"MyApplication"。在实际应用中，你应该根据你的需求来设置这些值。

此外，如果你的类包含更多的属性或者更复杂的数据结构，你可能需要扩展saveSettings和loadSettings方法以处理这些情况。你也可以考虑使用其他持久化机制，如QFile和QDataStream，特别是当你需要保存大量的数据或更复杂的数据结构时。

4.将MyPersistentClass头文件和资源文件分开

在Qt项目中，将类的声明（头文件）和实现（源文件）分开是一种常见的做法。这有助于提高代码的可读性和可维护性。对于MyPersistentClass，我们可以将其分为头文件（MyPersistentClass.h）和源文件（MyPersistentClass.cpp）。

下面是MyPersistentClass.h的内容：

#ifndef MYPERSISTENTCLASS_H  
#define MYPERSISTENTCLASS_H  
  
#include <QObject>  
#include <QString>  
  
class MyPersistentClass : public QObject  
{  
    Q_OBJECT  
    Q_PROPERTY(QString name READ name WRITE setName)  
    Q_PROPERTY(int age READ age WRITE setAge)  
  
public:  
    explicit MyPersistentClass(QObject *parent = nullptr);  
  
    QString name() const;  
    void setName(const QString &name);  
  
    int age() const;  
    void setAge(int age);  
  
    void saveSettings() const;  
    void loadSettings();  
  
private:  
    QString m_name;  
    int m_age;  
};  
  
#endif // MYPERSISTENTCLASS_H

接下来是MyPersistentClass.cpp的内容：

#include "MyPersistentClass.h"  
#include <QSettings>  
#include <QDebug>  
  
MyPersistentClass::MyPersistentClass(QObject *parent)  
    : QObject(parent), m_name("DefaultName"), m_age(0) {}  
  
QString MyPersistentClass::name() const  
{  
    return m_name;  
}  
  
void MyPersistentClass::setName(const QString &name)  
{  
    m_name = name;  
}  
  
int MyPersistentClass::age() const  
{  
    return m_age;  
}  
  
void MyPersistentClass::setAge(int age)  
{  
    m_age = age;  
}  
  
void MyPersistentClass::saveSettings() const  
{  
    QSettings settings("MyCompany", "MyApplication");  
    settings.setValue("name", m_name);  
    settings.setValue("age", m_age);  
}  
  
void MyPersistentClass::loadSettings()  
{  
    QSettings settings("MyCompany", "MyApplication");  
    m_name = settings.value("name", "DefaultName").toString();  
    m_age = settings.value("age", 0).toInt();  
}

在Qt项目中，你通常还需要一个.pro文件来配置项目的构建选项。确保你的.pro文件包含了必要的模块，比如core，并且指定了源文件和头文件：

QT += core  
  
CONFIG += c++11  
  
# The following define makes your compiler emit warnings if you use  
# any feature of Qt which is marked deprecated. Please consult the  
# documentation of the deprecated API in order to know how to port your code away from it.  
DEFINES += QT_DEPRECATED_WARNINGS  
  
# You can also make your code fail to compile if it uses deprecated APIs.  
# In order to do so, uncomment the following line.  
# DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0  
  
SOURCES += \  
    MyPersistentClass.cpp \  
    main.cpp  
  
HEADERS += \  
    MyPersistentClass.h

最后，你的main.cpp文件应该包含MyPersistentClass的头文件，并像之前那样使用该类：

#include <QCoreApplication>  
#include "MyPersistentClass.h"  
  
int main(int argc, char *argv[])  
{  
    QCoreApplication app(argc, argv);  
  
    MyPersistentClass obj;  
  
    // 加载设置  
    obj.loadSettings();  
    qDebug() << "Loaded settings: Name =" << obj.name() << ", Age =" << obj.age();  
  
    // 修改属性  
    obj.setName("NewName");  
    obj.setAge(30);  
  
    // 保存设置  
    obj.saveSettings();  
    qDebug() << "Saved settings: Name =" << obj.name() << ", Age =" << obj.age();  
  
    // [可选] 再次加载设置以验证保存是否成功  
    // MyPersistentClass obj2;  
    // obj2.loadSettings();  
    // qDebug() << "Reloaded settings: Name =" << obj2.name() << ", Age =" << obj2.age();  
  
    return app.exec();  
}

现在，你的MyPersistentClass的声明和实现已经被分开到了不同的文件中，这使得代码更加清晰和易于维护。

写：QSettings 向指定的配置文件中写入数据_qsettings qvariant写入配置文件-CSDN博客

组：qt 配置文件中组怎么表示_qt begingroup-CSDN博客