When to use new-operator?

Question

When should I use the new-operator?
In my example I get the same result using two different methods:

#include <iostream>
int main() {
    int *p1;
    int n1 = 5;
    p1 = &n1;

    int *p2;
    p2 = new int;
    *p2 = 5;

    std::cout << *p1 << std::endl;
    std::cout << *p2 << std::endl;
    return 0;
}

Answer 1

The purpose of using dynamically allocated memory is one (or many) of the following

• Run-time control over object's lifetime. E.g. the object is created manually by new and destroyed manually by delete at user's desire.
• Run-time control over object's type. E.g. you can deside the actual type of polymorphic object at run-time.
• Run-time control over objects' quantity. E.g. you can decide the array size or the number of elements in the list at run-time.
• When the object is simply too big to be reasonably placed into any other kind of memory. E.g. a large input-output buffer that is too big to be allocated on stack

In your specific example none of these reasons apply, which means that there's simply no point in using dynamic memory there.

Answer 2

Considering recent C++11 and upcoming C++14 standarts, you should mostly use new operator while programming in languages with garbage collection, such a Java or C#. It is quite natural for these languages. But in modern C++ you can (and mostly always should) avoid allocating memory directly. We have a nice set of smart pointers instead now.

Answer 3

Use new when you want to allocate from the heap, not the stack. Or moving up a level of abstraction. Use new when you need the allocated memory to remain allocated after you the function (more properly scope) in which it is allocated may (in the case of threading) have exited.

Answer 4

You should use new when you wish an object to remain in existence until you delete it. If you do not use new then the object will be destroyed when it goes out of scope.

Some people will say that the use of new decides whether your object is on the heap or the stack, but that is only true of variables declared within functions.

Allocating (and freeing) objects with the use of 'new' is far more expensive than if they are allocated in-place so its use should be restricted to where necessary.

Answer 5

In this piece of your code you do deal with memory, but with automatic memory. The compiler sorts out for you where to store each variable. you have p1 pointing at n1 but most work was done automatically.

int *p1;
int n1 = 5;
p1 = &n1;ou

However in the next piece of code you request to dynamically allocate an int

int *p2;
p2 = new int;
*p2 = 5;

here you have created a new integer that has been stored dynamically, therefore you should also delete it otherwise you have created your first memory leak. If you allocate dynamically you have to take care you delete it after use.

delete p2;

This is the largest diference when you start to allocate memory using new do delete it otherwise the deconstrucor of an instance of an object will not run and therefore not clear the memory you have allocated.

Answer 6

int * p2 = new int;

The new int part tells the program you want some new storage suitable for holding an operator uses the type to figure out how many bytes are needed. Then it finds the memory and returns the address. Next, you assign the address to p2, which is declared to be of type pointer-to-int. Now p2 is the address and *p2 is the value stored there. Compare this with assigning the address of a variable to a pointer:

int n1;
int * p1 = &n1;

In both cases (p1 and p2), you assign the address of an int to a pointer. In the second case, you can also access the int by name: p1. In the first case, your only access is via the pointer. Remember that you should use delete for freeing the memory allocated by new

delete p2;

You need to read some good books ... I think that "C++ Primer plus" is a good one for you