兼容 C++ 中的可变长度结构

Question

在标准 C 中，您可以使用大小为 0 的数组结束结构，然后过度分配它以向数组添加可变长度维度：

struct var
{
    int a;
    int b[];
}

struct var * x=malloc(sizeof(var+27*sizeof(int)));

如何在 C++ 中以标准（可移植）方式做到这一点？ 可以限制最大可能大小，显然不必在堆栈上工作

我在想：

class var
{
...
private:
  int a;
  int b[MAX];
};

然后使用分配器或重载 new/delete 以根据所需大小分配不足：

(sizeof(var) - (MAX-27)*sizeof(int)

但是，虽然它似乎有效，但我不想维护它。

是否有一种完全标准/便携的更简洁的方式？

Answer 1

虽然这不是直接回答您的问题——我要指出的是，在 C++ 中更好的做法是将 STL 库用于这种可变长度数组——它是安全且简单的，并且任何愿意维护的人都能理解它在你之后。

class var
{
...
private:
  int a;
  std::vector<int> b; // or use std::deque if more to your liking
};

现在您可以像其他任何课程一样对其进行新的更新；

var* myvar = new var;

您可以像使用旧类型数组一样使用它，而无需显式分配内存（尽管这不是大多数 ++ 程序员所做的）

myvar->b[0] = 123;
myvar->b[1] = 123;
myvar->b[2] = 123;

Answer 2

更简洁的方法是使用继承：

class Parent
{
  public:
    virtual int get_b(unsigned int index) = 0;
  protected:  
    int a;
};

class Child1
: public Parent
{
  public:
    int get_b(unsigned int index)
    {
        return b[index];  // Should have index bounds checking.
    }
  private:
    int b[20];
};

继承允许您调整父类成员的大小和数量。

Answer 3

这里有针对 C:http://www.open-std.org/jtc1/sc22/wg14/www/docs/dr_051.html 的缺陷报告提交

响应是，将数组声明为您将需要的最大大小（或者实际上您也可以为整数设置最大可能大小）是一个“更安全的习惯用法”并且它是严格符合的。这个想法是，不是 over 分配并因此超出数组的声明大小，您实际上 under 分配并且仅访问数组声明边界内的内存。

这应该适用于 C++，只要它没有改变那些规则，它不应该有这些规则，因为它应该与 C 非常兼容。如果有人知道 C++ 特定的东西会使这个解决方案无效，请通知我。

只要您将此实现隐藏在定义良好的接口后面，就不会有任何维护问题。

Answer 4

是的，您可以，尽管您不能将其声明为数组成员。您可以使用参考：

struct s {
    int ( & extra_arr )[];

    s() : extra_arr( reinterpret_cast< int (&)[] >( this[1] ) {}
};

实际上，这将使用指针的存储价值，尽管理论上它不需要。这门课不是POD，归结于理论和实践之间的差异。

---

您也可以将reinterpret_cast 放入非静态成员函数中：

struct s {
    int ( & get_extra() )[]
        { return reinterpret_cast< int (&)[] >( this[1] ); }

    int const ( & get_extra() const )[]
        { return reinterpret_cast< int const (&)[] >( this[1] ); }
};

现在访问需要函数调用语法（内联将消除除调试构建之外的机器代码差异），但不会浪费存储空间，对象将是 POD，除非 POD 规则有一些其他例外。

通过一些 ABI 调整，例如 #pragma pack，这可以获得完全的 C 二进制兼容性。无论如何，序列化应用程序通常都需要进行此类调整。

这也支持 const 正确性，而之前的解决方案允许修改 const 对象（因为它不知道数组是同一对象的一部分）。

样板文件可以泛化为 CRTP 基类（在 C++11 中甚至仍允许派生类为 POD），或扩展为定义 C++ 访问器或 C 灵活成员的预处理器宏。

---

请注意，这些解决方案都没有比原始 C 做更多的事情。特殊的成员函数不会复制灵活数组，并且类不支持函数参数或子对象。

Answer 5

简单地做 C 方式的变体有什么问题？

如果结构必须保持纯粹的 POD，C 方式就可以了。

struct var
{
    int a;
    int b[1];

    static std::shared_ptr<var> make_var(int num_b) {
        const extra_bytes = (num_b ? num_b-1 : 0)*sizeof(int);
        return std::shared_ptr<var>(
                new char[sizeof(var)+extra_bytes ],
                [](var* p){delete[]((char*)(p));});
}

因为它是一个 POD，所以一切都像在 C 中一样工作。

---

如果b 不能保证是 POD，那么事情会变得更有趣。我还没有测试过它，但它看起来或多或少是这样的。请注意，make_var 依赖于 make_unique，因为它使用 lambda 析构函数。没有这个你可以让它工作，但它是更多的代码。这就像 C 的方式一样，除了它使用构造函数和析构函数干净地处理可变数量的类型，并处理异常

template<class T>
struct var {
    int a;

    T& get_b(int index) {return *ptr(index);}
    const T& get_b(int index) const {return *ptr(index);}

    static std::shared_ptr<var> make_var(int num_b);
private:
    T* ptr(int index) {return static_cast<T*>(static_cast<void*>(&b))+i;}
    var(int l);
    ~var();
    var(const var&) = delete;
    var& operator=(const var&) = delete;

    typedef typename std::aligned_storage<sizeof(T), std::alignof(T)>::type buffer_type;
    int len;
    buffer_type b[1];
};
template<class T> var::var(int l)
    :len(0)
{
    try {
        for (len=0; len<l; ++len)
            new(ptr(i))T();
    }catch(...) {
        for (--len ; len>=0; --len)
            ptr(i)->~T();
        throw;
    }
}
template<class T> var::~var()
{
    for ( ; len>=0; --len)
        ptr(i)->~T();
}
template<class T> std::shared_ptr<var> var::make_var(int num_b)
{
    const extra_bytes = (num_b ? num_b-1 : 0)*sizeof(int);
    auto buffer = std::make_unique(new char[sizeof(var)+extra_bytes ]);
    auto ptr = std::make_unique(new(&*buffer)var(num_b), [](var*p){p->~var();});
    std::shared_ptr<var> r(ptr.get(), [](var* p){p->~var(); delete[]((char*)(p));});
    ptr.release();
    buffer.release;
    return std::move(r);
}

由于这是未经测试的，它甚至可能无法编译，并且可能存在错误。我通常会使用std::unique_ptr，但我懒得制作适当的独立删除器，而当删除器是 lambda 时，unique_ptr 很难从函数返回。如果您想使用这样的代码，请使用适当的独立删除器。

Answer 6

好的 - （因为我不确定，所以没有提出问题）因为在我看来，从目前的答案来看，目前没有比 over 分配更好的方法，我想知道如果这有助于维护：

template <class BASE, class T>
class dynarray
{
public:
    BASE base;
    const size_t size;
    T data[1]; // will be over allocated

    static dynarray * create(size_t data_size)
    {
        return new(data_size) dynarray(data_size);
    }
    void operator delete(void *p)
    {
        ::operator delete(p);
    }
private:
    void * operator new (size_t full_size, size_t actual)
    {
        if (full_size != sizeof(dynarray))
        {
            // inheritence changed size - allocate it all
            return ::operator new(sizeof(dynarray));
        }

        return ::operator new(sizeof(dynarray) + (actual-1)*sizeof(T));
    }
    void operator delete(void *p, size_t) // matching delete
    {
        ::operator delete(p);
    }
    dynarray(size_t data_size) : size(data_size)
    {
    }
};

用法有点生硬，但可能更好：

typedef dynarray<double,int,27> dyn;
dyn * x=dyn::create(7);
x->data[5]=28;
x->base=5.3;

编辑：将实现从 under 分配更改为 over 分配

Answer 7

另一种方法是使用placement new

#include <cstdlib>

class var
{
    ...
private:
    int a;
    int b[1];
};

var * x = new(malloc(sizeof(var) + (27-1)*sizeof(var::b))) var;

在这种情况下，在分配的内存上调用构造函数

删除结构使用：

x->~var(); // only if var have a destructor
free(x);

或者更好，给 var 添加一个删除操作符并使用 delete：

struct var {
    ...
    operator delete(void* ptr) throw() { free(ptr); }
};
var * x = ...
delete x;

最好和正确的方法是使用静态函数来创建实例并将构造函数私有化： 类变量 { 民众： ... 静态 var * create(int size, ) throw() { 新的(malloc(sizeof(var) + (27-1)*sizeof(b)))) var(); } 无效运算符删除（无效*ptr）{免费（ptr）； }

private:
    int a;
    int b[1];
    var(<args>) { ... }
};

var * x = var::create(27);
delete x;

注意：我使用大小为 1 的数组，因为并非所有编译器都支持未定义和 0 大小的数组。

Answer 8

template <size_t MAX>
class var
{
   ...
private:
  int a;
  int b[MAX];
};

在每个模板实例化中，MAX 是一个可以在循环中使用的常量。然后你可以构造任意长度的变量。

var<7> v7;
var<100> v100;

或者typedef他们

typedef var<10> myVar;