Qt中数据共享

文章目录

• 前言
• 在源文件中声明全局变量并在头文件中引用的方法
• • [推荐做法：使用 extern 声明](#推荐做法：使用 extern 声明)
  • • [1. 在源文件中定义全局变量](#1. 在源文件中定义全局变量)
    • [2. 创建对应的头文件声明这些变量](#2. 创建对应的头文件声明这些变量)
    • [3. 在其他文件中使用全局变量](#3. 在其他文件中使用全局变量)
  • 注意事项
  • 单例模式替代方案示例
• 单例模式代码详解
• • 你提供的单例模式代码分析
  • • 头文件部分 (`appglobals.h`)
    • 源文件部分 (`appglobals.cpp`)
  • 关键点详解
  • 使用示例
  • 为什么优于全局变量
  • 线程安全增强版
• 总结

---

前言

提示：这里可以添加本文要记录的大概内容：

项目需要：

---

提示：以下是本篇文章正文内容，下面案例可供参考

在源文件中声明全局变量并在头文件中引用的方法

在 Qt/C++ 项目中，如果你需要在源文件(.cpp)中声明全局变量，然后在头文件(.h)中引用这些变量，可以按照以下方式实现：

推荐做法：使用 extern 声明

1. 在源文件中定义全局变量

// globals.cpp
#include "globals.h"

// 定义全局变量
QString globalAppName = "MyQtApplication";
int globalCounter = 0;
WorkerThread* globalWorkerThread = nullptr;

2. 创建对应的头文件声明这些变量

// globals.h
#ifndef GLOBALS_H
#define GLOBALS_H

#include <QString>
class WorkerThread; // 前向声明

// 使用extern声明全局变量
extern QString globalAppName;
extern int globalCounter;
extern WorkerThread* globalWorkerThread;

#endif // GLOBALS_H

3. 在其他文件中使用全局变量

在任何需要访问这些全局变量的源文件中：

// mainwindow.cpp
#include "globals.h" // 包含全局变量声明

void MainWindow::someFunction()
{
    // 使用全局变量
    setWindowTitle(globalAppName);
    globalCounter++;
    
    if(globalWorkerThread) {
        // 操作全局线程指针
    }
}

注意事项

1. 避免头文件中定义变量：

   • 不要在头文件中直接定义变量（除非是静态类成员）
   • 这样会导致多重定义错误，当多个源文件包含该头文件时

2. 线程安全：

   • 全局变量在多线程环境下需要特别小心
   • 考虑使用 QMutex 或 QReadWriteLock 保护共享数据

   // globals.cpp
   QMutex globalCounterMutex;
   
   // 使用时
   {
       QMutexLocker locker(&globalCounterMutex);
       globalCounter++;
   }

3. 初始化顺序：

   • 全局变量的初始化顺序是不确定的
   • 避免依赖其他全局变量进行初始化

4. 更好的替代方案：

   • 考虑使用单例模式替代全局变量
   • 或者使用应用程序级的对象来管理这些"全局"状态

单例模式替代方案示例

比全局变量更安全的方式：

// appglobals.h
#ifndef APP_GLOBALS_H
#define APP_GLOBALS_H

#include <QObject>
#include <QString>

class AppGlobals : public QObject
{
    Q_OBJECT
public:
    static AppGlobals& instance();
    
    QString appName() const;
    void setAppName(const QString &name);
    
    int counter() const;
    void incrementCounter();
    
private:
    AppGlobals(QObject *parent = nullptr);
    AppGlobals(const AppGlobals&) = delete;
    AppGlobals& operator=(const AppGlobals&) = delete;
    
    QString m_appName;
    int m_counter;
};

#endif // APP_GLOBALS_H

// appglobals.cpp
#include "appglobals.h"

AppGlobals& AppGlobals::instance()
{
    static AppGlobals instance;
    return instance;
}

AppGlobals::AppGlobals(QObject *parent) 
    : QObject(parent), m_appName("MyQtApplication"), m_counter(0)
{
}

// 实现其他成员函数...

使用方式：

AppGlobals::instance().setAppName("NewName");
int count = AppGlobals::instance().counter();

这种方式比裸全局变量更安全，更易于维护，并且支持信号槽机制。

单例模式代码详解

单例模式是一种创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点。在 Qt 应用中，单例模式常用于管理全局状态或共享资源。

你提供的单例模式代码分析

头文件部分 (appglobals.h)

#ifndef APP_GLOBALS_H
#define APP_GLOBALS_H

#include <QObject>
#include <QString>

class AppGlobals : public QObject
{
    Q_OBJECT
public:
    // 1. 获取单例实例的静态方法
    static AppGlobals& instance();
    
    // 2. 访问方法
    QString appName() const;
    void setAppName(const QString &name);
    
    int counter() const;
    void incrementCounter();
    
private:
    // 3. 私有构造函数
    AppGlobals(QObject *parent = nullptr);
    
    // 4. 删除拷贝构造函数和赋值运算符
    AppGlobals(const AppGlobals&) = delete;
    AppGlobals& operator=(const AppGlobals&) = delete;
    
    // 5. 成员变量
    QString m_appName;
    int m_counter;
};

#endif // APP_GLOBALS_H

源文件部分 (appglobals.cpp)

#include "appglobals.h"

// 6. 实现静态实例方法
AppGlobals& AppGlobals::instance()
{
    static AppGlobals instance;  // 局部静态变量，线程安全(C++11起)
    return instance;
}

// 7. 实现构造函数
AppGlobals::AppGlobals(QObject *parent) 
    : QObject(parent), m_appName("MyQtApplication"), m_counter(0)
{
}

// 8. 实现其他成员函数...
QString AppGlobals::appName() const {
    return m_appName;
}

void AppGlobals::setAppName(const QString &name) {
    m_appName = name;
}

int AppGlobals::counter() const {
    return m_counter;
}

void AppGlobals::incrementCounter() {
    m_counter++;
}

关键点详解

1. 静态实例方法 (instance()):

   • 这是获取单例对象的唯一入口
   • 使用局部静态变量确保只创建一个实例
   • C++11 保证局部静态变量初始化是线程安全的

2. 私有构造函数:

   • 防止外部代码直接实例化类
   • 只能通过 instance() 方法获取对象

3. 删除拷贝操作:

   • = delete 明确禁止拷贝构造和赋值操作
   • 防止通过拷贝创建新实例

4. 成员变量:

   • 所有全局状态封装在类内部
   • 可以通过方法安全访问和修改

5. 继承 QObject:

   • 使单例类能够使用 Qt 的信号槽机制
   • 可以发出信号通知状态变化

使用示例

// 设置应用程序名称
AppGlobals::instance().setAppName("My Awesome App");

// 获取应用程序名称
QString name = AppGlobals::instance().appName();

// 增加计数器
AppGlobals::instance().incrementCounter();

// 获取当前计数值
int count = AppGlobals::instance().counter();

为什么优于全局变量

1. 更好的封装性:

   • 数据和行为封装在一起
   • 可以添加验证逻辑和方法

2. 延迟初始化:

   • 单例在第一次访问时才创建
   • 避免程序启动时的初始化顺序问题

3. 线程安全:

   • C++11 保证静态局部变量初始化是线程安全的
   • 可以添加额外的锁机制保护成员变量

4. 可扩展性:

   • 未来可以轻松改为多例模式
   • 易于添加日志、监控等功能

5. 与 Qt 框架集成:

   • 可以发送信号通知状态变化
   • 支持 Qt 的属性系统

线程安全增强版

如果需要更严格的线程安全控制：

// 添加头文件
#include <QMutex>

class AppGlobals : public QObject {
    // ...
private:
    static QMutex m_mutex;  // 添加互斥锁
    // ...
};

// 在.cpp中
QMutex AppGlobals::m_mutex;

int AppGlobals::counter() const {
    QMutexLocker locker(&m_mutex);
    return m_counter;
}

void AppGlobals::incrementCounter() {
    QMutexLocker locker(&m_mutex);
    m_counter++;
}

这种实现方式在多线程环境下能保证成员变量的安全访问。

总结

学习使人快乐！

音乐使人愉悦！

日积月累使人充实和自信！