What is the difference in using NEW and not using it in C++

Question

What is the difference between

Kwadrat* k1 = new Kwadrat(1,2,3);
k1->field = 0;
Kwadrat k2(1,2,3);
k2.field = 0;

The first one is the pointer to the allocated memory, the second one is the object(where is it, on system stack?) why the second is worse? When we use first, whend the second one?

Answer 1

Dynamic allocation on the heap (uses new):
Kwadrat* k1 = new Kwadrat(1,2,3);
Object creation on the stack (without new):
Kwadrat k2(1,2,3);

Check out this Stack Overflow question for extended discussion about the stack and heap. Brian R. Bondy's answer does a nice job of comparing the two, while Jeff Hill's answer gives you some more nitty gritty details.

For a dangerously small summary:

• you must delete objects you create with new, or else your code will suffer from memory leaks
• you don't have to worry about manually deleting objects created on the stack because C++ Resource Allocation is Initialization (RAII) takes care of that for you
• The stack can overflow if you attempt very large allocations.
• As for which one you should use, that depends on the intended scope of the object you are creating

Answer 2

Using new dynamically creates an object on the heap meaning it will persist even if the pointer (k1*) goes out of scope.

This can be handy, but if it goes out of scope and you don't keep a copy of the pointer around it is permanently lost and causes a memory leak. This means you will lose the space used by that resource as long as the program executes. This is the downside of dynamically allocating memory with new, you have to track it and manually free it with the delete operator which takes extra work.

Doing it the other way creates a stack object which will be destroyed once it leaves scope, which is usually preferable.

Often when using dynamic memory creation with new, people work to gain this stack-like functionality by wrapping the dynamically created object in another object which will destroy it when it goes out of scope. This pattern is called Resource Acquisition is Initialization (RAII). This is most useful with reference counting so your objects can still be persisted out of scope, but will be destroyed when nothing refers to them any longer.

Answer 3

new allocates an object on the heap. Your second example allocates memory on the stack. As soon as the function where you allocate k2 returns the memory won't be valid anymore (the destructor of k2 will of course be called first). You need to use new if you want the object to live longer than the function that creates it.

Answer 4

new lets you specify the storage for the allocation you request. allocations via new/new[] are generally on the heap (e.g. wrapping malloc), but ultimately implementation defined. as well, the compiler could have enough information to bypass this in some cases.

where is it, on system stack?

Technically, you would typically write C++ to the specification -- of an abstract machine.

But typically, yes - the object is allocated on the thread's stack.

Why the second is worse? When we use first, when the second one?

The second should be your default because it is very clear, the compiler manages its lifetime and allocation for you, and also very fast. Some exceptions to this include:

• when you have a large allocation (stack sizes are relatively small)
• sometimes when you want to share the allocation with another thread
• when you want to pass the allocation to another thread
• when you want the object to live beyond the scope of the method, and you will typically use a smart pointer or other container which will delete the object properly.

in short, there's a lot less that could go wrong (using the second), and far less time is spent creating allocations via the general purpose system allocators.