为结构数组分配内存块

Question

我需要在一块可靠的内存中分配一个此结构的数组。 “char *extension”和“char *type”的长度在编译时是未知的。

struct MIMETYPE
{
 char *extension;
 char *type;
};

如果我使用“new”操作符来单独初始化每个元素，内存可能会分散。这就是我尝试为其分配单个连续内存块的方式：

//numTypes = total elements of array
//maxExtension and maxType are the needed lengths for the (char*) in the struct
//std::string ext, type;
unsigned int size = (maxExtension+1 + maxType+1) * numTypes;
mimeTypes = (MIMETYPE*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);

但是，当我尝试像这样加载数据时，当我稍后尝试访问它时，数据全部乱序和分散。

for(unsigned int i = 0; i < numTypes; i++)
{
 //get data from file
 getline(fin, line);
 stringstream parser.str(line);
 parser >> ext >> type;

 //point the pointers at a spot in the memory that I allocated
 mimeTypes[i].extension = (char*)(&mimeTypes[i]);
 mimeTypes[i].type = (char*)((&mimeTypes[i]) + maxExtension);

 //copy the data into the elements
 strcpy(mimeTypes[i].extension, ext.c_str());
 strcpy(mimeTypes[i].type, type.c_str());
}

谁能帮帮我？

编辑：

unsigned int size = (maxExtension+1 + maxType+1);
mimeTypes = (MIMETYPE*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size * numTypes);

for(unsigned int i = 0; i < numTypes; i++)
    strcpy((char*)(mimeTypes + (i*size)), ext.c_str());
    strcpy((char*)(mimeTypes + (i*size) + (maxExtension+1)), type.c_str());

Answer 1

你混合2分配：

1) 管理 MIMETYPE 数组和

2) 管理字符数组

可能是（我不太了解您的目标）：

struct MIMETYPE
{
    char extension[const_ofmaxExtension];
    char type[maxType];
};

最好以表格形式分配线性项：

new MIMETYPE[numTypes];

Answer 2

我将搁置这是过早的优化（你应该只使用 std::string、std::vector 等），因为其他人已经说过了。

我看到的根本问题是您对 MIMETYPE 结构和它们将指向的字符串使用相同的内存。无论你如何分配它，指针本身和它所指向的数据都不能在内存中占据确切相同的位置。

---

假设您需要一个包含 3 种类型的数组，并让 MIMETYPE* mimeTypes 指向您为它们分配的内存。

这意味着您将这段记忆视为包含：

8 bytes: mime type 0
8 bytes: mime type 1
8 bytes: mime type 2

现在，考虑一下您在下一行代码中所做的事情：

mimeTypes[i].extension = (char*)(&mimeTypes[i]);

extension 被设置为指向与 MIMETYPE 结构本身相同的内存位置。那是行不通的。当后续代码写入extension 指向的位置时，它会覆盖 MIMETYPE 结构。

同样，这段代码：

strcpy((char*)(mimeTypes + (i*size)), ext.c_str());

正在将字符串数据写入您希望 MIMETYPE 结构占用的同一内存中。

---

如果您真的想将所有必要的内存存储在一个连续的空间中，那么这样做会有点复杂。您需要分配一块内存以在其开头包含 MIMETYPE 数组，然后是字符串数据。

例如，假设您需要 3 种类型。假设扩展字符串 (maxExtension) 的最大长度为 3，类型字符串 (maxType) 的最大长度为 10。在这种情况下，您的内存块需要布置为：

8 bytes: mime type 0
8 bytes: mime type 1
8 bytes: mime type 2
4 bytes: extension string 0
11 bytes: type string 0
4 bytes: extension string 1
11 bytes: type string 1
4 bytes: extension string 2
11 bytes: type string 2

因此，要正确分配、设置和填充所有内容，您需要执行以下操作：

unsigned int mimeTypeStringsSize = (maxExtension+1 + maxType+1);
unsigned int totalSize = (sizeof(MIMETYPE) + mimeTypeStringsSize) * numTypes;
char* data = (char*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, totalSize);

MIMETYPE* mimeTypes = (MIMETYPE*)data;
char* stringData = data + (sizeof(MIMETYPE) * numTypes);

for(unsigned int i = 0; i < numTypes; i++)
{
    //get data from file
    getline(fin, line);
    stringstream parser.str(line);
    parser >> ext >> type;

    // set pointers to proper locations
    mimeTypes[i].extension = stringData + (mimeTypeStringsSize * i);
    mimeTypes[i].type = stringData + (mimeTypeStringsSize * i) + maxExtension+1;

    //copy the data into the elements
    strcpy(mimeTypes[i].extension, ext.c_str());
    strcpy(mimeTypes[i].type, type.c_str());
}

---

（注意：我的字节布局解释基于 32 位代码的典型行为。64 位代码将有更多空间用于指针，但原理是相同的。此外，我的实际代码不管 32/64 位差异如何，这里写的应该都能工作。）

Answer 3

您需要做的是获取垃圾收集器并管理堆。使用 RAII 进行对象销毁的简单收集器编写起来并不难。这样，您可以简单地分配收集器并知道它将是连续的。但是，在确定这对您来说是一个严重的问题之前，您应该真正地、真正地进行分析。发生这种情况时，您可以 typedef 许多 std 类型（例如 string 和 stringstream）来使用您的自定义分配器，这意味着您可以返回到 std::string 而不是那里的 C 风格字符串恐怖。

Answer 4

您确实必须知道extension 和type 的长度才能连续分配MIMETYPE（如果“连续”意味着extension 和type 实际上是在对象内分配的）。由于您说extension 和type 的长度在编译时是未知的，因此您不能在数组或vector 中执行此操作（vector 的总长度可以在运行时设置和更改，但是在编译时必须知道各个元素的大小，如果不知道extension 和type 的长度，就无法知道该大小。

我个人建议使用MIMETYPEs 中的vector，并将extension 和type 字段都设为strings。您的要求听起来很可疑，就像过早的优化一样，直觉是解引用指针很慢，尤其是在指针导致缓存未命中的情况下。除非您有实际数据表明读取这些字段是一个实际瓶颈，否则我不会担心这一点。

但是，我可以想到一个可能的“解决方案”：当MIMETYPE 对象内的extension 和type 字符串短于特定阈值时，您可以分配它们，否则动态分配它们：

#include <algorithm>
#include <cstring>
#include <new>

template<size_t Threshold> class Kinda_contig_string {
    char contiguous_buffer[Threshold];
    char* value;

    public:

    Kinda_contig_string() : value(NULL) { }

    Kinda_contig_string(const char* s)
    {
         size_t length = std::strlen(s);
         if (s < Threshold) {
             value = contiguous_buffer;
         }
         else {
             value = new char[length];
         }

         std::strcpy(value, s);
    }

    void set(const char* s)
    {
        size_t length = std::strlen(s);

        if (length < Threshold && value == contiguous_buffer) {
            // simple case, both old and new string fit in contiguous_buffer
            // and value points to contiguous_buffer
            std::strcpy(contiguous_buffer, s);
            return;
        }

        if (length >= Threshold && value == contiguous_buffer) {
            // old string fit in contiguous_buffer, new string does not
            value = new char[length];
            std::strcpy(value, s);
            return;
        }

        if (length < Threshold && value != contiguous_buffer) {
            // old string did not fit in contiguous_buffer, but new string does
            std::strcpy(contiguous_buffer, s);
            delete[] value;
            value = contiguous_buffer;
            return;
        }

        // old and new strings both too long to fit in extension_buffer
        // provide strong exception guarantee
        char* temp_buffer = new char[length];
        std::strcpy(temp_buffer, s);
        std::swap(temp_buffer, value);
        delete[] temp_buffer;
        return;
    }

    const char* get() const
    {
        return value;
    }
}

class MIMETYPE {
    Kinda_contig_string<16> extension;
    Kinda_contig_string<64> type;

  public:
    const char* get_extension() const
    {
        return extension.get();
    }

    const char* get_type() const
    {
        return type.get();
    }

    void set_extension(const char* e)
    {
        extension.set(e);
    }

    // t must be NULL terminated
    void set_type(const char* t)
    {
        type.set(t);
    }

    MIMETYPE() : extension(), type() { }

    MIMETYPE(const char* e, const char* t) : extension(e), type(t) { }
};

我真的无法在不感到内疚的情况下支持这一点。

Answer 5

在字符串之间添加一个字节...扩展名和类型不是 \0 终止的方式。

在这里你分配允许额外的 \0 - OK

unsigned int size = (maxExtension+1 + maxType+1) * numTypes;
mimeTypes = (MIMETYPE*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);

这里你没有为扩展的结尾留下任何空间 \0（如果字符串 len == maxExtension）

 //point the pointers at a spot in the memory that I allocated
 mimeTypes[i].extension = (char*)(&mimeTypes[i]);
 mimeTypes[i].type = (char*)((&mimeTypes[i]) + maxExtension);

我认为应该是

 mimeTypes[i].type = (char*)((&mimeTypes[i]) + maxExtension + 1);