主页 / 问题 / 646119
Accepted
maestro
Asked:2020-03-30 15:59:02 +0800 CST2020-03-30 15:59:02 +0800 CST

在共享内存中存储对象

  • 772

如果一个应用程序使用进程之间共享的内存，它可以在这个内存中存储一​​个类对象吗？这个对象有什么要求？它可以有虚拟方法吗？如果这个对象开始动态分配内存会发生什么？

这是一个将对象放在共享内存中的示例，我认为其中应该没有陷阱。

QSharedMemory InteropMemory("name1");
QSystemSemaphore InteropSemaphore("name2", 1);
InteropSemaphore.acquire();
if (!InteropMemory.attach())
{
    bool created = InteropMemory.create(sizeof(InteropData));
    if (!created)
        qDebug() << InteropMemory.errorString();
    InteropMemory.lock();
    char *data = (char*)InteropMemory.data();
    InteropData *object = new InteropData();
    memcpy(data, object, sizeof(InteropData));
    delete object;
    InteropMemory.unlock();
}
InteropSemaphore.release();

class InteropData
{
public:
    InteropData();
    bool nextPointAllowed();

    int attach();

    void detach(int procNumber);

    void allow(int procNumber);

    void reset();
private:
    bool m_allowNextPoint[INTEROP_MAX_PROC_COUNT];
    bool m_procTerminated[INTEROP_MAX_PROC_COUNT];
    int m_count;
};

在代码中，此对象的使用方式如下：

InteropMemory.lock();
InteropData *object = (InteropData*)InteropMemory.data();
object->allow(1);
InteropMemory.unlock();

更新。还有一个问题，当共享内存被释放时，对象的析构函数不会被调用。可以自己调用吗？在这种情况下有必要吗？

c++

2 个回答

  1. 如果一个应用程序使用进程之间共享的内存，它可以在这个内存中存储一​​个类对象吗？

    是的你可以。使用展示位置新

    这个对象有什么要求？

    该对象必须了解它可以从不同的进程访问。这里有很多很多功能。最简单的事情是同步，通常的互斥锁在这里无济于事。进程间同步的手段是必要的。但这只是麻烦的一半。事实上，每个应用程序都会编译类，并且由于编译器/链接器的不同设置或不同版本的编译器/链接器，对象会有所不同。而这可以产生多种特殊效果。最简单的是对齐。正因为如此，从流程的角度来看，第二个数组的偏移量和 m_count 变量可能会略有不同。

    它可以有虚拟方法吗？

    也许。谁拦着他。最主要的是一切都已正确选择和配置。

    如果这个对象开始动态分配内存会发生什么？

    如果它只是分配内存，它将在调用进程的上下文中分配它。其他进程将无法访问此内存。但它可以在共享内存中分配。然后它会更容易。

    还有一个问题，当共享内存被释放时，对象的析构函数不会被调用。

    是的，它不会

    可以自己调用吗？

    能够。像那样的地方

    obj.~InteropData();

    或者，更准确地说，使用 placement delete

    在这种情况下有必要吗？

    如果你使用 placement new 并且对象不创建第三方实体（例如打开文件），那么你不能调用析构函数。

    • 3
  2. Best Answer

    如果一个应用程序使用进程之间共享的内存，它可以在这个内存中存储一​​个类对象吗？

    简短的回答是否定的，我不推荐它。

    您可以将POD类型存储在共享内存中。

    这个操作不仅对共享内存不安全，对普通内存也是不安全的：

    memcpy(data, object, sizeof(InteropData));

    因为 基于 OOP，您必须为这种情况调用复制构造函数。调用方法后：

    delete object;

    在析构函数中，您将销毁上面复制的“类”引用的对象。

    也许上面的代码甚至可以工作，但它不是一种安全的方法，并且可能无法在其他平台/编译器上工作。

    它还显然假定您要将此对象传递给另一个进程。但至少，它可以引用旧进程的内存地址。

    如果我是你，我会将结构复制到共享内存中：

    struct InteropDataStruct
{
    bool m_allowNextPoint[INTEROP_MAX_PROC_COUNT];
    bool m_procTerminated[INTEROP_MAX_PROC_COUNT];
    int m_count;
}

    在阅读时，我会将此结构传递给类构造函数：

    InteropMemory.lock();
InteropDataStruct *data = (InteropDataStruct*)InteropMemory.data();
object = new InteropData(data);
object->allow(1);
InteropMemory.unlock();
    • 3

相关问题