C ++中兼容的可变长度结构 [英] compliant variable length struct in C++
问题描述
在标准C语言中,您可以使用大小为0的数组结束结构,然后对其进行过度分配以向该数组添加可变长度的维度:
In standard C you can end a struct with an array of size 0 and then over allocate it to add a variable length dimension to the array:
struct var
{
int a;
int b[];
}
struct var * x=malloc(sizeof(var+27*sizeof(int)));
如何在C ++中以标准(便携式)方式做到这一点?
可以限制最大可能的大小,而且显然不必在堆栈上工作
How can you do that in C++ in a standard (portable) way? It is okay to have a constraint of max posible size and obviously doesn't have to work on the stack
我在想:
class var
{
...
private:
int a;
int b[MAX];
};
,然后使用分配器或根据需要的大小重载new / delete以分配不足:
and then use allocators or overload new/delete to under allocate based on the required size:
(sizeof(var)-(MAX-27)* sizeof(int)
(sizeof(var) - (MAX-27)*sizeof(int)
但是,尽管它似乎可以工作,这不是我想要维护的东西。
But, while it seems to work, its not something I'd want to have to maintain.
是否有一种更清洁的方式完全是标准/便携式的?
Is there a cleaner way that is fully standard/portable?
推荐答案
简单地使用C语言的变体有什么问题?
What's wrong with simply doing a variant of the C way?
如果结构必须保持纯POD
If the structure has to remain purely POD, the C way is fine.
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,所以一切都像d
since it's a POD, everything works just like it did in C.
如果不能保证 b
POD,然后事情变得更加有趣。我没有测试过任何东西,但看起来或多或少都像这样。请注意, make_var
依赖 make_unique
,因为它使用了lambda析构函数。您可以在不使用此功能的情况下使其正常运行,但这需要更多代码。就像C方式一样,除了它干净地用构造函数和析构函数处理可变数量的类型,并处理异常
If b
is not guaranteed to be POD, then things get more interesting. I haven't tested any of it, but it would look more or less like so. Note that make_var
relies on make_unique
, because it uses a lambda destructor. You can make it work without this, but it's more code. This works just like the C way, except it cleanly handles variable amounts of types with constructors and destructors, and handles exceptions
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
,但是我懒得做适当的独立删除器,而 unique_ptr
是当删除程序是lambda时,很难从函数返回。如果您想使用这样的代码,请使用适当的独立删除器。
Since this is untested, it probably doesn't even compile, and probably has bugs. I'd normally use std::unique_ptr
but I'm too lazy to make proper standalone deleters, and unique_ptr
is hard to return from a function when the deleter is a lambda. On the off chance you want to use code like this, use a proper standalone deleter.
这篇关于C ++中兼容的可变长度结构的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持IT屋!