分配具有可变长度数组成员的结构

Question

我知道我可以使用new char[n] 创建一个n 字符数组。即使n 不是编译时间常数，这也有效。

但是假设我想要一个大小变量，后跟 n 个字符：

我的第一次尝试如下：

struct Test
{
  std::size_t size;
  char a[];
};

但是，new Test[n] 似乎没有达到我的预期，而是分配了nsizes。

我还发现sizeof(std::string)在ideone是4，看来它可以在一个块中同时分配大小和char数组。

有什么方法可以实现我所描述的（大概是std::string 已经做到的）？

Answer 1

虽然您可以这样做（它经常在 C 中用作某种变通方法），但不建议这样做。但是，如果这真的是您想要做的......这里有一种方法可以用于大多数编译器（包括那些不能很好地使用 C99 增强功能的编译器）。

#define TEST_SIZE(x) (sizeof(Test) + (sizeof(char) * ((x) - 1)))

typedef struct tagTest
{
    size_t size;
    char a[1];
} Test;

int elements = 10; // or however many elements you want
Test *myTest = (Test *)malloc(TEST_SIZE(elements));

C99 之前的 C 规范不允许结构中的零长度数组。为了解决这个问题，创建了一个包含单个元素的数组，并将比请求的元素计数少一个添加到实际结构的大小（大小和第一个元素）以创建预期的大小。

Answer 2

你可以使用placement new:

#include <new>

struct Test {
    size_t size;
    char a[1];

    static Test* create(size_t size)
    {
        char* buf = new char[sizeof(Test) + size - 1];
        return ::new (buf) Test(size); 
    }

    Test(size_t s) : size(s)
    {
    }

    void destroy()
    {
        delete[] (char*)this;
    }
};

int main(int argc, char* argv[]) {
    Test* t = Test::create(23);
    // do whatever you want with t
    t->destroy();
}

Answer 3

您还可以使用“长度为 1 的数组”技巧。这是在 C 中：

struct Test {
    size_t size;
    char a[1];
}

int want_len = 2039;
struct Test *test = malloc(sizeof(struct Test) + (want_len - 1));
test->size = want_len;

GCC 也支持“0 长度”数组来达到这个目的： http://gcc.gnu.org/onlinedocs/gcc/Zero-Length.html

Answer 4

如果我理解正确，您需要一个类来存储指向动态分配的以长度为前缀的字符串的单个指针。您可以利用 char* 可以安全地为任何内容设置别名这一事实来做到这一点。

一个简单的实现，只是为了展示it can be done：

class LPS
{
private:
    char* ptr;

public:
    LPS() noexcept : ptr(nullptr) {} // empty string without allocation
    explicit LPS(std::size_t len) {
        // Allocate everything in one go
        // new[] gives storage aligned for objects of the requested size or less
        ptr = new char[sizeof(std::size_t) + len];
        // Alias as size_t
        // This is fine because size_t and char have standard layout
        *reinterpret_cast<std::size_t*>(ptr) = len;
    }
    explicit LPS(char const* sz) {
        std::size_t len = std::char_traits<char>::length(sz);
        ptr = new char[sizeof(std::size_t) + len;
        *reinterpret_cast<std::size_t*>(ptr) = len;
        std::copy(sz, sz + len, ptr + sizeof(std::size_t));
    }
    LPS(LPS const& that) {
        if(that.ptr) {
            ptr = new char[sizeof(std::size_t) + that.size()];
            std::copy(that.ptr, that.ptr + sizeof(std::size_t) + that.size(), ptr);
        } else ptr = nullptr;
    }
    LPS(LPS&& that) noexcept {
        ptr = that.ptr;
        that.ptr = nullptr;
    }
    LPS& operator=(LPS that) {
        swap(that);
        return *this;
    }
    ~LPS() noexcept {
        // deleting a null pointer is harmless, no need to check
        delete ptr;
    }
    void swap(LPS& that) noexcept {
        std::swap(ptr, that.ptr);
    }
    std::size_t size() const noexcept {
         if(!ptr) return 0;
         return *reinterpret_cast<std::size_t const*>(ptr);
    }
    char* string() noexcept {
         if(!ptr) return nullptr;
         // the real string starts after the size prefix
         return ptr + sizeof(std::size_t);
    }
};

Answer 5

让我们在 C++ 中使用std::vector 让事情变得简短而甜蜜。

struct Test
{
   std::size_t size;
   char *a;  // Modified to pointer

   Test( int size ): size(size), a(new char[size+1])
   {}
};

std::vector<Test> objects(numberOfObjectsRequired,argumentToTheConstructor);