C++ 动态内存分配使用“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

Answer 2

For static allocation, you must specify the size as a constant:

  MyObj  arrObject[5];

For dynamic allocation, that can be varied at run-time:

  MyObj  *arrObject = new MyObj[n];

The different between new and malloc is that new will call the ctor for all those objects in the array, while malloc just gives you raw memory.

Answer 3

if you wanna use an array and you dont know the exact size at the compile time, thats when dynamic memory allocation steps in. See the example below,

int a[3] = {1,2,3};  //<= valid in terms of syntax;

however,

int size = 3;
int a[size] = {1,2,3} //<= compile error

in order to fix this,

int* ArrayPtr = new int[size];

also, when freeing it, call delete[] ArrayPtr; instead of delete alone, coz we are talking abt freeing a BLOCK of memory at this moment.

Answer 4

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.

malloc and realloc take the number of bytes to allocate instead of the type you want to allocate, and also don't call any constructors (again, they only know about the size to allocate). This works fine in C (as it really has more of a size system than a type system), but with C++'s much more involved type system, it falls short. In contrast, new is type safe (it doesn't return a void* as malloc does) and constructs the object allocated for you before returning.

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.

This is a compiler extension (and part of C99), it is NOT standard C++. The standard requires that a 'normal' array have a bound which is known at compile time. However, it seems your compiler decided to support variable length 'normal' arrays anyways.

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.

Its dynamic in that you don't know the size until run time (and thus can be different across different invocations). Compile time vs. run time is a distinction you don't often run across in other languages (in my experience at least), but it is crucial to understanding C++.