c++ dynamic memory allocation using "new"

Question

I'm new to C++, trying to learn by myself (I've got Java background).

There's this concept of dynamic memory allocation that I can assign to an array (for example) using new.

In C (and also in C++) I've got malloc and realloc that are doing that. In C++ they've added the new for some reason I can't understand.

I've read a lot about the difference between a normal array that goes to the stack while the dynamic allocated array goes to the heap.

So what I understand is that by using new I'm allocating space in the heap which will not be deleted automatically when finished a function let's say, but will remain where it is until I finally, manually free it.

I couldn't find practical examples of using the dynamic memory allocation over the normal memory.

1. It's said that I can't allocate memory through runtime when using normal array. Well, probably I didn't understand it right because when I tried to create a normal array (without new) with a capacity given as an input by the user (like arr[input]), it worked fine.

here is what I mean:

int whatever;
cin>>whatever;

int arr2[whatever];

for (int i = 0; i < whatever; i++) {
    arr2[i]=whatever;
    cout<<arr2[i];

}

1. I didn't really understand why it's called dynamic when the only way of extending the capacity of an array is to copy it to a new, larger array.

I understood that the Vector class (which I haven't yet learned) is much better to use. But still, I can't just leave that gap of knowledge begin and I must understand why exactly it's called dynamic and why should I use it instead of a normal array. Why should I bother freeing memory manually when I can't really extend it but only copy it to a new array?

Answer 1

When you know the size of an array at compile time you can declare it like this and it will live on the stack:

int arr[42];

But if you don't know the size at compile time, only at runtime, then you cannot say:

int len = get_len();
int arr[len];

In this case you must allocate the array at runtime. In this case the array will live on the heap.

int len = get_len();
int* arr = new int[len];

When you no longer need that memory you need to do a delete [] arr.

std::vector is a variable size container that allows you to allocate and reallocate memory at runtime without having to worry about explicitly allocating and freeing it.

int len = get_len();
std::vector<int> v(len); // v has len elements
v.resize(len + 10); // add 10 more elements to the vector