Re: Zero-size array as struct member

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


   How many times does this have to be repeated?

   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.

   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
     };

   Then you allocate such structs with

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

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

   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.

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