Re: Zero-size array as struct member
On Aug 18, 1:30 pm, thomas <freshtho...@gmail.com> wrote:
Hi, I need your help.
----------
struct SvrList{
unsigned int uNum;
GameSvr svr[0]; //line A};
---------
Once I declared a struct like this to store server list info.
It's supposed to be used like this.
----------
SvrList* pList = (SvrList*)malloc(sizeof(
SvrList) + svrNum*sizeof(GameSvr));
pList->uNum, pList->svr[0], pList->svr[1].... blabla..
---------
The vs2005 compiler gives me the "nonstandard extension used : zero-
sized array in struct/union" warning though.
I may keep my eye closed to the warning since everything looks fine.
But I don't know whether anything bad may happen to me some day due to
running environment changes(porting to different platforms, or any
other conditions).
One work-around way is to declare a one-sized array as struct member,
but I didn't see any substantial changes except no warning in this
case.
Any body give some suggestions?
If you ever plan to change actual number of elements in your object,
just drop this crap and use a vector. If not, ponder this (I am
presuming that your uNum is number of elements you have there):
template<typename T>
// hbvla: Heap Based Variable Length Array
class hbvla : public boost::noncopyable // Can't assign, nor copy-
construct.
{
public:
void operator delete(void* p)
{
delete reinterpret_cast<char*>(p);
}
void operator delete(void* p, size_t /*cElements*/)
{ // Compiler calls this in case of exception in ctor
// that gets called through overloaded operator new (see ^^^).
// (note matched size_t cElements argument in two cases)
delete reinterpret_cast<char*>(p);
}
static hbvla* create(size_t cElements) { return new (cElements)
hbvla(cElements); }
~hbvla()
{
destroy_elements();
}
// Trivial helper methods.
size_t size() const { return _size; }
T& operator[](size_t i) { assert(i < size()); return _elements[i]; }
const T& operator[](size_t i) const { assert(i < size()); return
_elements[i]; }
T* begin() { return _elements; }
const T* begin() const { return _elements; }
T* end() { return _elements+size(); }
const T* end() const { return _elements+size(); }
private:
size_t _size;
T _elements[1]; // Standard does not allow 0.
// 1 is OK, but I could have put anything due to particular design.
// ^^^
void* operator new(size_t objectSize, size_t cElements)
{ // Only this operator new shall be used.
// Handle overflow.
const size_t MaxElements = (SIZE_MAX-objectSize)/cElements;
if (cElements > MaxElements)
throw std::bad_alloc();
return new char[objectSize + cElements*sizeof(T)];
}
/*
Using "standard" operators new with hbvla is does not work, so hide
them
(and don't implement them).
The [] form is not really needed in this case because default ctor
is hidden,
but I am leaving it here for informative purposes.
operator delete[] does not work either.
*/
void* operator new[](size_t objectSize);
void* operator new(size_t objectSize);
void operator delete[](void*);
typedef hbvla<T> this_type; // helper typedef.
// ctor: we must empty-construct our _elements from 1 to
(cElements-1).
// Empty ctor is dangerous. But since we have a ctor, we don't need
to write and hide anything.
hbvla(size_t cElements) : _size(0)
{
if (!cElements)
return; // Strange but possible.
// Construct elements from 1 to (cElements-1).
// Use ScopeGuard to destruct partially-constructed array of
elements.
_size = 1;
ScopeGuard elementsGuard = MakeObjGuard(*this,
&this_type::destroy_elements);
while (_size<cElements)
{
T* p = &_elements[_size];
new (p) T;
_size++;
}
elementsGuard.Dismiss();
}
void destroy_elements()
{ // destroy elements that we create "by hand"
// (C++ runtime destroys _element[0]).
std::for_each(begin()+1, end(), &this_type::destroy);
}
static void destroy(const T& element)
{
element.~T();
}
};
Goran.