Why is it possible to add define elements in an array of length 0 in C++

Question

Im reading up for a exam in C++ and just fideling around in order to get a better sense of the language. My understanding is that arrays in c++ are defined with a fixed length either before run time or dynamically. Knowing this I don't understand why C++ accepts this. I wouldn't think that it would be possible to add element to an array of length 0;

int * TestArray = new int[0];
TestArray[0]=10;
TestArray[1]=20;
TestArray[2]=30;

It's [undefined behaviour](http://en.cppreference.com/w/cpp/language/ub) -- it only *appears* to work. — G.M., May 09 '17 at 07:45
Standard C++ doesn't allow arrays with length 0 (see http://stackoverflow.com/a/6180200/646887). — Klas Lindbäck, May 09 '17 at 08:25
Saying "What is the purpose of allocating a specific amount of memory for arrays in C++?" answers "Why is it possible to add define elements in an array of length 0 in C++" is a stretch. — Gonen I, Dec 01 '17 at 18:01

score 4 · Answer 1 · answered May 09 '17 at 07:46

4

Writing to array elements outside of the valid size is Undefined Behaviour. It's a bug and your program is ill formed. But the compiler is not required to issue a diagnostic (although most will with the right warning options). It's your responsibility to follow the rules.

answered May 09 '17 at 07:46

Jesper Juhl

30,449
3
47
70

Thank you. I didn't know of the term undefined behavior – Christian Ahm May 09 '17 at 08:38

Gonen I · Answer 2 · 2017-05-09T08:23:01.790

You may not access any elements in a zero sized array. It results in undefined runtime behavior. However, zero sized arrays are allowed for various reasons.

First, it allows you to make functions less complicated by skipping size checks:

   void f(size_t n)
   {
    int * ptr = new int[n];
    //...
    delete[] ptr;
   }

instead of:

void f(size_t n)
{
 if (n>0)
 {
  int * ptr = new int[n];
  //...
  delete[] ptr;
 }
}

Second, the intent was to make it easy for compiler writers to implement new using malloc, and this is the defined behavior for malloc.

The GCC c compiler docs give this reason: "Zero-length arrays are allowed in GNU C. They are very useful as the last element of a structure that is really a header for a variable-length object: "

struct line {
  int length;
  char contents[0];
};

struct line *thisline = (struct line *)
  malloc (sizeof (struct line) + this_length);
thisline->length = this_length;

[without it], you would have to give contents a length of 1, which means either you waste space or complicate the argument to malloc.

score 0 · Answer 3 · answered May 09 '17 at 08:15

My professor told me that because c++ and c can access and write outside of array bounds,it is one of the main reasons they are used to create operating systems. For example you can even do something like

arr[-1]=5;

I believe it is worth mentioning.However this can lead to undefined behavior.

Why is it possible to add define elements in an array of length 0 in C++

3 Answers3