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

Answer 1

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++.

Answer 2

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 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

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.