QSharedMemory 避免程序重复启动

QSharedMemory sharedMemory;
sharedMemory.setKey("NewKey"); // 设置新键
if (!sharedMemory.attach()) {
    // 共享内存不存在，尝试创建
    if (!sharedMemory.create(size)) {
        // 处理错误
    }
}

2.内容

在Qt框架中，QSharedMemory 是一种高效的跨进程通信方式，通过唯一键值管理的共享内存段实现程序单例化。以下是其避免重复启动的原理、实现方法及最佳实践：

一、核心原理

唯一键值标识
每个共享内存段通过唯一字符串（如应用名+UUID）标识，确保全局唯一性。
创建与附加机制
- 首次启动：成功创建共享内存段（create()返回true），程序继续运行。
- 重复启动：创建失败但可附加到现有段（attach()返回true），说明已有实例运行，当前进程退出。
同步控制
通过lock()和unlock()保证多进程读写安全。

二、实现步骤

基础版：直接检测重复启动

#include <QApplication>
#include <QSharedMemory>
#include <QMessageBox>

int main(int argc, char *argv[]) {
    QApplication a(argc, argv);
    QSharedMemory sharedMemory("MyAppUniqueKey"); // 设置唯一键值

    if (sharedMemory.create(1)) { // 尝试创建1字节内存段
        return a.exec(); // 创建成功，正常启动
    } else {
        QMessageBox::warning(nullptr, "警告", "程序已在运行中！");
        return 0; // 创建失败，提示重复启动
    }
}

增强版：存储PID并验证进程状态

#include <QCoreApplication>
#include <QSharedMemory>
#include <QProcess>

int main(int argc, char *argv[]) {
    QCoreApplication a(argc, argv);
    QSharedMemory sharedMemory;
    const QString key = "MyAppUniqueKey";
    sharedMemory.setKey(key);

    // 尝试创建共享内存（存储PID所需大小）
    if (!sharedMemory.create(sizeof(qint64))) {
        if (sharedMemory.attach()) { // 附加到现有内存段
            sharedMemory.lock();
            qint64 storedPid = *reinterpret_cast<qint64*>(sharedMemory.data());
            sharedMemory.unlock();

            // 检查进程是否存活
            QProcess process;
            process.start("kill", QStringList() << "-0" << QString::number(storedPid));
            if (process.waitForFinished() && process.exitCode() == 0) {
                qDebug() << "程序已在运行，PID:" << storedPid;
                return 1;
            } else {
                // 旧进程已退出，覆盖共享内存
                sharedMemory.detach();
                if (!sharedMemory.create(sizeof(qint64))) {
                    qDebug() << "共享内存创建失败";
                    return 1;
                }
            }
        }
    }

    // 存储当前进程PID
    sharedMemory.lock();
    *reinterpret_cast<qint64*>(sharedMemory.data()) = QCoreApplication::applicationPid();
    sharedMemory.unlock();

    // 退出时自动释放内存
    QObject::connect(&a, &QCoreApplication::aboutToQuit, [&]() {
        sharedMemory.detach();
    });

    return a.exec();
}

三、关键注意事项

键值冲突风险
使用复杂键值（如UUID或应用名_版本号）避免与其他程序冲突。
残留内存段处理
- 程序崩溃可能导致内存段未释放，需通过detach()或系统工具清理。
- Windows系统限制：共享内存对象在进程结束后可能残留，需显式调用detach()。
跨平台兼容性
QSharedMemory在Linux/Windows/macOS均有效，但不同系统对共享内存的管理策略可能不同。

四、对比其他方案

方法	优点	缺点
QSharedMemory	跨平台、无外部依赖、高效	需处理残留内存段，Windows限制较多
QLocalServer	Qt5+自动清理残留文件	Qt6已弃用`QLocalSocket`，仅限Unix-like系统
系统信号量	无需键值管理	跨平台性差，依赖操作系统API

五、最佳实践建议

键值设计
使用应用名_主版本号_UUID格式，例如：
"MyApp_v1.0_D8E3DB53-3565-7BDE-EC83-A3F1C953E850"
异常处理
添加errorString()检查，捕获创建/附加失败的具体原因。
资源释放
在aboutToQuit信号中调用detach()，确保内存段及时释放。

跨平台适配
结合#ifdef Q_OS_WIN处理Windows特殊逻辑，例如：

#ifdef Q_OS_WIN
// Windows专用清理逻辑
#else
// Unix-like系统通用逻辑
#endif

通过合理使用QSharedMemory，开发者可以高效实现程序单例化，同时兼顾跨平台需求。对于Qt6及以上版本，建议优先评估QSharedMemory的适用性，或结合其他IPC机制（如ZeroMQ）增强可靠性。

3.关联链接

4.关联知识

1.QSharedMemory

QSharedMemory 是 Qt 框架中用于实现多进程间共享内存通信的核心类，以下从定义、原理、使用场景及代码实践四个维度为您详细解析：

一、核心定义

本质：基于操作系统共享内存机制封装的跨进程通信工具。
特点：
- 高效性：直接操作内存，避免文件/网络传输开销。
- 跨平台：支持 Windows、Linux、macOS 等主流系统。
- 线程安全：通过 lock()/unlock() 实现同步控制。

二、工作原理

键值标识
每个共享内存段由唯一字符串（如 "MyApp_SharedMemory"）标识，确保多进程精准定位。
生命周期管理
- 创建：create(size) 分配指定大小的内存段。
- 附加：attach() 连接到已存在的内存段。
- 分离：detach() 断开与内存段的关联。
同步机制
通过 lock() 获取独占访问权，操作完成后 unlock() 释放，防止数据竞争。

三、典型应用场景

场景类型	具体案例	性能优势
高频数据传递	实时传感器数据流、音视频处理中间结果	延迟低于 1ms，远快于文件/网络传输
大文件缓存共享	多进程协同处理大型图像/3D模型	避免重复加载，节省数百MB内存占用
进程状态同步	多实例程序配置热更新	瞬间广播变更，替代轮询机制
单例模式实现	确保程序全局唯一运行实例	比文件锁快 10 倍以上

四、代码实战指南

基础读写示例

// 进程A：写入数据
QSharedMemory sharedMem("DataShare");
if (sharedMem.create(1024)) {
    sharedMem.lock();
    memcpy(sharedMem.data(), "Hello from Process A", 24);
    sharedMem.unlock();
}

// 进程B：读取数据
QSharedMemory sharedMem("DataShare");
if (sharedMem.attach()) {
    sharedMem.lock();
    qDebug() << "Received:" << sharedMem.data();
    sharedMem.unlock();
    sharedMem.detach(); // 操作完成后及时释放
}

单例模式进阶实现

#include <QCoreApplication>
#include <QSharedMemory>
#include <QProcess>

int main(int argc, char *argv[]) {
    QCoreApplication a(argc, argv);
    QSharedMemory singleton("MyApp_Singleton");

    // 尝试创建内存段（存储PID）
    if (!singleton.create(sizeof(qint64))) {
        if (singleton.attach()) {
            // 验证旧进程是否存活
            singleton.lock();
            qint64 storedPid = *reinterpret_cast<qint64*>(singleton.data());
            singleton.unlock();

            QProcess process;
            process.start("kill", QStringList() << "-0" << QString::number(storedPid));
            if (process.waitForFinished() && process.exitCode() == 0) {
                qDebug() << "已有实例运行，PID:" << storedPid;
                return 1;
            }
        }
        // 清理残留内存段后重试
        singleton.detach();
        if (!singleton.create(sizeof(qint64))) {
            qDebug() << "初始化失败";
            return 1;
        }
    }

    // 记录当前PID
    singleton.lock();
    *reinterpret_cast<qint64*>(singleton.data()) = QCoreApplication::applicationPid();
    singleton.unlock();

    // 程序退出时自动清理
    QObject::connect(&a, &QCoreApplication::aboutToQuit, [&]() {
        singleton.detach();
    });

    return a.exec();
}

五、注意事项

键值冲突
建议使用 UUID 或 应用名_版本号 组合，例如：
"com.example.MyApp_v2.0_D8E3DB53-3565-7BDE-EC83-A3F1C953E850"
残留处理
- Windows 系统需显式调用 detach()，否则可能导致内存段永久残留。
- 可通过 QSharedMemory::errorString() 诊断错误原因。
跨平台差异
- Linux/macOS 共享内存对象在进程退出后自动释放。
- Windows 需依赖 detach() 主动释放，否则需重启系统清理。

六、性能对比

方法	延迟	吞吐量	适用场景
QSharedMemory	<1ms	>1GB/s	高频小数据、进程状态同步
TCP Socket	10-100ms	10-100MB/s	跨机器通信、大数据传输
文件映射	5-50ms	50-500MB/s	超大文件共享、内存映射文件
QLocalSocket	2-20ms	10-50MB/s	本地进程通信（Qt5已弃用）

通过合理选择 QSharedMemory，开发者可以在保证跨平台兼容性的同时，实现接近硬件极限的通信效率。对于需要严格单例控制的场景，建议结合进程PID验证机制以增强健壮性。

2.QSharedMemory构造函数

QSharedMemory 是 Qt 提供的一个类，用于跨进程共享内存。它的构造函数允许你创建一个共享内存段。在使用 QSharedMemory 时，多个进程可以访问同一个内存段，从而实现数据共享。下面是 QSharedMemory 构造函数的一些关键信息：

构造函数

QSharedMemory(const QString &key)
- 参数：key 是一个字符串，用于标识共享内存段。不同进程使用相同的 key 来访问同一个共享内存段。
- 说明：这是最常用的构造函数。它创建一个与 key 相关联的共享内存对象。如果具有相同 key 的共享内存段已经存在，你可以尝试将其附加到本进程。

示例

#include <QCoreApplication>
#include <QSharedMemory>
#include <QDebug>

int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv);

    QSharedMemory sharedMemory("SharedMemoryExample");

    if (!sharedMemory.create(1024)) {  // 创建 1 KB 的共享内存段
        qDebug() << "Unable to create shared memory segment.";
        return 1;
    }

    sharedMemory.lock();
    char *to = static_cast<char*>(sharedMemory.data());
    const char data[] = "Hello, Shared Memory!";
    memcpy(to, data, sizeof(data));
    sharedMemory.unlock();

    qDebug() << "Data written to shared memory:" << data;

    // 在其他进程中，你可以使用相同的 key 来访问这个共享内存段。

    return app.exec();
}

注意事项

唯一性：key 应该是唯一的，尽量避免与其他应用程序冲突。
锁定和解锁：在读写共享内存时，应使用 lock() 和 unlock() 方法来避免数据竞争。
错误处理：检查 create() 和 attach() 的返回值，以确保成功创建或附加到共享内存。
平台限制：不同操作系统对共享内存的支持和限制可能不同，请参阅 Qt 文档以获取详细信息。

通过 QSharedMemory，你可以方便地在多个进程之间共享数据，适用于需要高效进程间通信的场景。

3.QSharedMemory 构造函数有几种重载

QSharedMemory 是 Qt 框架中用于进程间共享内存操作的类，其构造函数存在 2 种重载形式，具体如下：

1. 带键构造（直接关联共享内存）

cpp复制代码

QSharedMemory(const QString &key, QObject *parent = nullptr)

功能：通过指定父对象 parent 和共享内存的唯一标识符 key，直接构造一个关联到特定共享内存段的实例。
特点：由于 key 在构造时已被设置，可直接调用 create()（创建共享内存）或 attach()（附加到现有共享内存）进行操作。
适用场景：明确知道要操作的共享内存段的 key 时使用。

2. 无键构造（需后续设置键）

cpp复制代码

QSharedMemory(QObject *parent = nullptr)

功能：仅通过父对象 parent 构造实例，此时共享内存的 key 未被设置。
后续操作：需调用 setKey() 或 setNativeKey() 手动指定 key 后，才能使用 create() 或 attach()。
灵活性：允许在对象创建后再动态决定关联的共享内存段。

关键区别

重载形式	是否在构造时设置 key	是否可直接调用 create/attach
带 key 的构造函数	是	是
不带 key 的构造函数	否	需先设置 key

使用示例

带 key 构造：

QSharedMemory sharedMem("MySharedMemoryKey", this);
if (sharedMem.create(1024)) { // 直接创建共享内存
    // 写入数据...
}

无 key 构造：

QSharedMemory sharedMem(this);
sharedMem.setKey("DynamicKey"); // 后续设置 key
if (sharedMem.attach()) {       // 附加到现有共享内存
    // 读取数据...
}

设计意义

灵活性：无 key 构造允许动态绑定共享内存，适用于运行时决定操作目标的场景。
效率：带 key 构造减少了后续设置步骤，适合已知明确 key 的场景。

这两种重载形式覆盖了共享内存操作的典型需求，开发者可根据具体场景选择使用。

4.QSharedMemory 设置key的函数

QSharedMemory 类中用于设置共享内存键（key）的函数主要有以下两个，具体用法和区别如下：

1. `setKey(const QString &key)`

功能：为共享内存对象设置一个跨平台、Qt 应用程序通用的键。
特点：
- 自动去重：如果新键与当前键相同，函数会直接返回，不执行任何操作。
- 自动分离：如果共享内存对象已附加到某个内存段（即已调用 attach() 或 create()），设置新键前会自动调用 detach() 分离。
- 需重新关联：设置新键后，需重新调用 create()（创建新内存段）或 attach()（附加到现有内存段）才能操作共享内存。

示例：

QSharedMemory sharedMem;
sharedMem.setKey("NewKey"); // 设置新键
if (sharedMem.create(1024)) { // 需重新创建或附加
    // 操作共享内存...
}

2. `setNativeKey(const QString &key)`

功能：设置一个特定于平台、与非 Qt 应用程序兼容的本机键。
特点：
- 跨平台交互：允许 Qt 应用程序与非 Qt 应用程序（如使用 POSIX 共享内存或 Windows 文件映射的程序）交互。
- 失去保护机制：设置本机键后，lock() 和 unlock() 函数将失效，需自行实现同步机制（如信号量）。
- 典型用法：先创建默认共享内存对象，再设置本机键。

示例：

QSharedMemory sharedMem;
sharedMem.setNativeKey("NativeKey"); // 设置本机键
if (sharedMem.attach()) { // 直接附加到非 Qt 应用程序创建的共享内存
    // 操作共享内存（需自定义同步）...
}

关键区别

函数	键类型	适用场景	同步机制
`setKey()`	Qt 通用键	Qt 应用程序间共享内存	支持 `lock()`/`unlock()`
`setNativeKey()`	平台特定本机键	Qt 与非 Qt 应用程序交互	需自定义同步

使用建议

Qt 内部通信：优先使用 setKey()，利用 Qt 内置的同步机制简化开发。
跨框架交互：使用 setNativeKey()，但需自行处理同步和键的兼容性。

5.QSharedMemory的detach 重复调用会有什么后果

重复调用 QSharedMemory::detach() 的后果与调用时的共享内存状态及操作系统平台有关，以下是详细分析：

1. 正常情况：已附加时调用

首次调用：若进程已附加到共享内存段，首次调用 detach() 会成功分离进程与内存段。
- 返回值：true
- 系统行为：
  - Windows：QSharedMemory 不“拥有”内存段，内核会在所有进程退出后自动释放内存。
  - Unix/Linux：QSharedMemory“拥有”内存段，若这是最后一个附加进程，内核会立即释放内存段。
重复调用：若进程已分离（即未附加到内存段），再次调用 detach()：
- 返回值：false（分离失败）
- 系统行为：无实际影响，但可能掩盖逻辑错误（如误判附加状态）。

2. 异常情况：未附加时调用

直接调用：若进程未附加到内存段，调用 detach() 会直接返回 false。
后果：无实际影响，但需检查代码逻辑，避免无效调用。

3. 平台差异风险

Windows：重复调用相对安全，因内核管理内存段生命周期。
Unix/Linux：若其他进程仍在访问内存段，重复调用可能导致：
- 内存段提前释放：引发其他进程的访问错误（如段错误）。
- 数据竞争：若未正确同步，可能导致数据不一致。

最佳实践建议

调用前检查状态：

if (sharedMemory.isAttached()) {
    sharedMemory.detach();
}

避免盲目调用：确保在明确需要分离时再调用 detach()，尤其在多进程环境中。

错误处理：

if (!sharedMemory.detach()) {
    qDebug() << "Detach failed:" << sharedMemory.errorString();
}

总结

重复调用 detach() 在大多数情况下是安全的，但可能导致无效操作或隐藏逻辑错误。建议通过 isAttached() 预检，并谨慎处理返回值，以确保代码健壮性和跨平台兼容性。

6.QApplication::aboutToQuit 和在main函数内创建的一个对象的析够函数，那个能保证程序退出一定会被调用到。

在Qt框架中，QApplication::aboutToQuit信号与main函数内创建对象的析构函数，在程序退出时的调用可靠性存在以下差异：

1. `QApplication::aboutToQuit`信号

触发时机：
该信号在应用程序主事件循环即将退出时发出，例如：
- 调用QApplication::quit()或QCoreApplication::quit()后。
- 用户关闭所有窗口（若设置了QApplication::quitOnLastWindowClosed(true)）。
- 操作系统关闭会话（如注销或关机）。
可靠性分析：
- 正常情况：程序正常退出时，信号会被触发。
- 异常情况：若程序崩溃（如未捕获的异常、段错误），信号可能不会触发，因为主事件循环未正常退出。

2. `main`函数内创建对象的析构函数

调用时机：
C++标准规定，局部对象的析构函数在其作用域结束时自动调用。对于main函数内创建的对象：
- 当main函数执行完毕（即return语句）时，对象生命周期结束，析构函数被调用。
- 即使程序崩溃，只要崩溃发生在对象析构之后，析构函数仍会被调用（但崩溃本身可能导致未定义行为）。
可靠性分析：
- 正常情况：程序正常退出时，析构函数必然被调用。
- 异常情况：若程序在main函数结束前崩溃，析构函数可能无法执行完全（取决于崩溃发生的代码位置）。但根据C++标准，局部对象析构的调用由编译器保证，与程序退出方式无关。

3. 直接对比与结论

特性	`QApplication::aboutToQuit`信号	`main`函数内对象析构函数
触发条件	主事件循环正常退出	`main`函数作用域结束
异常情况处理	程序崩溃时可能不触发	即使程序崩溃，析构函数仍可能执行
调用顺序	在主事件循环退出前触发	在`main`函数返回前调用
跨平台一致性	依赖Qt事件循环实现	由C++标准保证，与平台无关

结论

若需执行与Qt事件循环相关的清理操作（如关闭窗口、释放资源），应优先使用QApplication::aboutToQuit信号，因为它能确保在事件循环退出前执行。
若需执行与对象生命周期严格绑定的清理操作（如释放内存、关闭文件），应依赖对象的析构函数，因为它的调用由C++标准保证，可靠性更高。

最佳实践

int main(int argc, char *argv[]) {
    QApplication app(argc, argv);
    
    // 创建局部对象（析构函数在main返回前调用）
    MyClass obj;
    
    // 连接aboutToQuit信号处理Qt相关清理
    QObject::connect(&app, &QApplication::aboutToQuit, []() {
        qDebug() << "Qt event loop is about to quit. Performing Qt-related cleanup...";
    });
    
    // ... 其他代码 ...
    
    return app.exec(); // main函数返回前，obj的析构函数被调用
}

关键总结：
对象析构函数在程序退出时的调用更可靠（由C++标准保证），而QApplication::aboutToQuit更适合处理与Qt事件循环相关的清理任务。两者结合使用可覆盖绝大多数退出场景。

7.c++ qt sharedMemory.attach()

在 C++ Qt 中，QSharedMemory::attach() 方法用于附加到已存在的共享内存段。共享内存是一种高效的进程间通信（IPC）方式，允许多个进程访问同一块内存区域。以下是关于 QSharedMemory::attach() 的详细说明：

`QSharedMemory::attach()` 的作用

附加到共享内存：如果共享内存已经存在（由其他进程创建），attach() 方法允许当前进程附加到该共享内存段，从而可以读写其中的数据。
返回值：返回一个布尔值，表示是否成功附加到共享内存。如果失败（例如共享内存不存在），则返回 false。

使用场景

多进程共享数据：当一个进程创建共享内存后，其他进程可以通过 attach() 附加到该内存，实现数据共享。
进程间通信：适用于需要高效传递数据的场景，比如实时数据交换、配置共享等。

基本用法

#include <QSharedMemory>
#include <QDebug>

int main() {
    QSharedMemory sharedMemory("MySharedMemoryKey");

    if (!sharedMemory.attach()) {
        qDebug() << "Failed to attach to shared memory. Maybe it doesn't exist?";
        return 1;
    }

    // 成功附加后，可以读写共享内存
    if (sharedMemory.lock()) {
        char *data = static_cast<char*>(sharedMemory.data());
        // 读取或写入数据...
        qDebug() << "Data from shared memory:" << data;
        sharedMemory.unlock();
    }

    sharedMemory.detach(); // 分离共享内存
    return 0;
}

关键注意事项

共享内存必须存在：
- 在调用 attach() 之前，确保共享内存已由其他进程创建（通过 QSharedMemory::create()）。
- 如果共享内存不存在，attach() 会失败。
同步机制：
- 多进程同时访问共享内存时，需使用同步机制（如 QMutex 或信号量）避免数据竞争。
- Qt 提供了 QSharedMemory::lock() 和 QSharedMemory::unlock() 方法来简单同步。
错误处理：
- 始终检查 attach() 的返回值，处理可能的错误（如共享内存不存在）。
内存管理：
- 使用 detach() 分离共享内存。
- 不要手动删除共享内存，除非你是创建者（通过 QSharedMemory::create()）。
跨平台兼容性：
- 共享内存在不同操作系统上的行为可能略有不同，需测试目标平台。

常见问题

为什么 attach() 失败？
- 共享内存未创建（检查创建进程的代码）。
- 共享内存名称（key）不匹配。
- 权限问题（确保进程有权限访问共享内存）。
如何确保数据一致性？
- 使用 lock() 和 unlock() 保护对共享内存的访问。
- 对于复杂场景，考虑使用信号量或事件通知机制。
共享内存的大小限制：
- 共享内存的大小受限于操作系统（通常较大，但需合理分配）。

总结

QSharedMemory::attach() 是 Qt 中实现进程间通信的关键方法，通过附加到已存在的共享内存段，可以高效地在多进程间共享数据。使用时需注意同步、错误处理和内存管理，以确保程序的稳定性和可靠性。

8.attach()如果成功表示内存已经创建了，attach()如果失败，表示内存还没创建，我可以创建内存。如果内存已经创建了，我直接create会有什么后果

在 Qt 中使用 QSharedMemory 时，attach() 和 create() 的行为需要谨慎处理。以下是关键点的详细解释：

1. `attach()` 失败后的处理

如果 attach() 失败（返回 false），通常意味着：

共享内存不存在（未被其他进程创建）。
权限不足（如文件系统权限问题）。

此时，你可以安全地调用 create() 来尝试创建共享内存：

QSharedMemory sharedMemory("MyKey");

if (!sharedMemory.attach()) {
    // 尝试创建共享内存
    if (!sharedMemory.create(size)) {
        qDebug() << "Failed to create shared memory!";
        return;
    }
    qDebug() << "Shared memory created successfully.";
}

2. 共享内存已存在时调用 `create()` 的后果

如果共享内存已经存在（即其他进程已经调用过 create() 或 attach()），此时调用 create() 可能会导致以下问题：

a. 潜在的数据覆盖

Qt 的行为：根据 Qt 文档，如果共享内存已存在，create() 可能会失败（返回 false），但某些情况下（尤其是不同操作系统或 Qt 版本）可能会尝试覆盖现有内存。
风险：如果覆盖发生，其他进程正在使用的共享内存数据会被破坏，导致未定义行为（如程序崩溃）。

b. 竞争条件

多进程竞争：如果多个进程同时尝试创建或附加到共享内存，可能引发竞争条件，导致不可预测的结果。

3. 最佳实践

为了避免上述问题，应遵循以下原则：

a. 检查共享内存是否存在

在调用 create() 之前，先尝试 attach()：

if (!sharedMemory.attach()) {
    // 共享内存不存在，尝试创建
    if (!sharedMemory.create(size)) {
        // 处理错误
    }
}

b. 使用同步机制

互斥锁：在多进程环境中，使用 QSystemSemaphore 或操作系统提供的同步机制（如信号量）来协调对共享内存的访问。
原子操作：确保创建和附加操作的原子性，避免竞争条件。

c. 错误处理

检查返回值：始终检查 attach() 和 create() 的返回值。
日志记录：记录错误信息，方便调试。

d. 资源管理

分离和删除：在不再需要共享内存时，调用 detach() 分离内存。只有创建者（调用 create() 的进程）应调用 destroy() 删除内存。

4. 示例代码（安全创建共享内存）

QSharedMemory sharedMemory("MyKey");
const int size = 4096; // 共享内存大小

// 尝试附加到现有内存
if (sharedMemory.attach()) {
    qDebug() << "Attached to existing shared memory.";
} else {
    // 尝试创建新内存
    if (sharedMemory.create(size)) {
        qDebug() << "Created new shared memory.";
    } else {
        qDebug() << "Failed to create shared memory. Error:" << sharedMemory.errorString();
        return;
    }
}

// 使用共享内存...
if (sharedMemory.lock()) {
    char *data = static_cast<char*>(sharedMemory.data());
    // 读写数据...
    sharedMemory.unlock();
}

sharedMemory.detach(); // 分离内存