Re: Zero-size array as struct member

From:

Ian Collins <ian-news@hotmail.com>

Newsgroups:

comp.lang.c++

Date:

Sun, 22 Aug 2010 17:19:03 +1200

Message-ID:

<8dbqa7Fpl6U9@mid.individual.net>

On 08/22/10 04:44 PM, Juha Nieminen wrote:

Ian Collins<ian-news@hotmail.com> wrote:

You are cheating. std::set<int> != std::vector<int> and is in no way an
equivalent to a dynamically allocated array.

Try your test with a vector, before and after reserving space (which is
the more realistic comparison).

How many times does this have to be repeated?

What, that you cheated?

The so-called struct hack is a technique for allocating a variable-length
struct. It's struct which has an array as the last element, and the size
of this array is determined at runtime by "overallocating" memory using
malloc(). When this last element is then indexed, this will access that
allocated memory.

I discovered that 30 odd years ago, no news there.

   So using the struct hack you would have:

     struct MyStruct
     {
         int size; // or whatever
         int array[0]; // or int array[1] if the compiler demands it
     };

or int array[] if you have a conforming C compiler.

Then you allocate such structs with

malloc(sizeof(MyStruct) + amount_of_elements * sizeof(int));

In the C world, yes.

Now you have a dynamically allocated instantiation of the struct, where
the size of the 'array' element is decided at runtime.

The struct hack is a C idiom which is seldom used in C++. In C++ we
have other techniques.

   The other option is to do it like:

     struct MyStruct
     {
         std::vector<int> array;

         MyStruct(int size): array(size) {}
     };

   Then you allocate the struct like:

     new MyStruct(amount_of_elements);

   (It has to be allocated dynamically if the struct instantiation needs to
survive the scope where it was created.)

   In the latter case there will be *two* allocations: One for the struct
and another for the std::vector. In the former case there will be only
one allocation.

Big deal.

std::vector::reserve has nothing to do with this.

neither has std::set.

--
Ian Collins