Question

I recently submitted a small program for an assignment that had the following two functions and a main method inside of it:

 /** 
  *  Counts the number of bits it
  *  takes to represent an integer a
  */
   int num_bits(int a)
   {
      int bitCount = 0;

      while(a > 0)
      {
         bitCount++;
         a = a >> 1; //shift to the right 1 bit
      }

      return bitCount;
    }

  /**
   * Converts an integer into binary representation
   * stored in an array
   */
   void int2bin_array(int a, int *b)
   {
      //stopping point in search for bits
      int upper_bound = num_bits(a);

      int i;
      for(i = 0; i < upper_bound; i++)
      {
         *(b+i) = (a >> i) & 1; //store the ith bit in b[i]
      }
   }

int main()
{
   int numBits = num_bits(exponent);
   int arr[numBits];     //<- QUESTION IS ABOUT THIS LINE 
   int2bin_array(exponent, arr);

   //do some operations on array arr
}

When my instructor returned the program he wrote a comment about the line I marked above saying that since the value of numBits isn’t known until run-time, initializing an array to size numBits is a dangerous operation because the compiler won’t know how much memory to allocate to array arr.

I was wondering if someone could:

1) Verify that this is a dangerous operation

2) Explain what is going on memory wise when I initialize an array like that, how does the compiler know what memory to allocate? Is there any way to determine how much memory was allocated?

Any inputs would be appreciated.

Answer 1

That’s a C99 variable length array. It is allocated at runtime (not by the compiler) on the stack, and is basically equivalent to

 char *arr = alloca(num_bits);

In this case, since you can know the upper bound of the function, and it is relatively small, you’d be best off with

 char arr[sizeof(int)*CHAR_BIT]; 

This array has a size known at compile time, will always fit everything you need, and works on platforms without C99 support.