Why does this not work: `int arr[size]` but this does `int* arr = new int[size]`?

Question

I'm currently studying C++. Coming from Java, lots of stuff is really weird to me.

At some point I tried to create an array of a size that's determined at runtime, like so:

int size = functionCall(argument);
int array[size];

This compiled and ran, but gave really weird output later in the program.

Someone told me I have to do this:

int size = functionCall(argument);
int* array = new int[size];

Because new allows stuff to be dynamically allocated, i.e. if I understand correctly allocated according to something that's only known at runtime.

Two questions:

1- Is my understanding of new correct?

2- Why doesn't C++ allow the first version of my code?

Answer 1

At some point I tried to create an array of a size that's determined at runtime, like so: This compiled and ran, but gave really weird output later in the program.

What you created was a non-standard extension called VLA (A.K.A. Variable-length Array). It should have worked, really, but since it didn't I assume something went wrong on your end.

Because new allows stuff to be dynamically allocated, i.e. if I understand correctly allocated according to something that's only known at runtime.

Yes, your intuition is correct.

1- Is my understanding of new correct?

Yes. You use new to dynamically allocate memory. But that opens another can of worms.

2- Why doesn't C++ allow the first version of my code?

The C++ standard just doesn't support VLAs. I feel like the reasoning for this is outside the scope of the question.

In either case, if you wanted a dynamic array based on a runtime variable in C++ we tend to use std::vector. You code would then end up being this:

std::size_t size = get_size();
std::vector<int> arr(size);

Now you could use the std::vector as if it was a regular C array. The benefits of using std::vector over raw new is that it relieves you of the burden of using delete[] and it also provides strong exception safety when faced with exceptions before you get to the line that calls delete[].

Answer 2

C++ (unlike modern C) does not allow you to initialize an array using a value that is computed at run-time. It is possible to do

int x[size];

in C++, but the value contained within size must be known by the compiler. Therefore, the following is legal

int const size = 10; // Known at compile-time
int x[size];

But the following is not

int size;
cin >> size; // we only know size at run-time
int x[size]; // ERROR!

The reason for this is restriction is technical and I won't go into it here since you're clearly new to the language. Just know that if you want to declare an array (without using the keyword new) you need to know the size of it at compile-time.

As an alternative, you should check out the container std::vector, which allows you to safely allocate an array dynamically, without having to use new and delete.

std::vector<int> xs(10); // allocate space for ten ints.

The benefit is that, due to vector's destructor, you don't have to worry about managing the memory it allocates, thus leading to safer code.

So, in summary:

1. Yes, your understanding of new is correct. If you only know the size at run-time, you need dynamic memory. However, avoid using new if at all possible: prefer vector.
2. C++ simply does not allow arrays to have sizes known at run-time. All arrays created on the stack must have their sizes known at compile-time. This is different than in C, where such a thing is allowed.

Answer 3

int size = functionCall(argument);
int* x = new int[size];

size is not known at compile time. it is known only at runtime. So you need to use heap allocation for your array. There is no way for the compiler to know what size this array should be at compile time, so it has to ask the heap memory allocator at run time to allocate enough space when it knows what size is. The new keyword is a request for heap memory.

if you did

static const int size = <constexpression>
int x[size];

for example if constexpression was 3 (a size_t convertible literal) or anything that was known at compile time, then it would use stack allocation, since the compiler would know at compile time how big the array should be and you would be allowed to do that.

If you want to create a contiguous array of ints who's size is only known at runtime, you should use std::vector which provides a safe wrapper around an array that can be dynamically resized at runtime:

std::vector<int> x(size);

If you know the size at compile time, you might even consider using std::array since it has a static size() method that does not take any extra storage and means you dont need to pass around a size as well (however it causes you instantiation cost at compile time per unique size):

std::array<int, size> x; // where size is known at compile time