0

I'm wondering when objects of classes allocate dynamic memory. Take the following statements, dealing with a class called "test":

test* pd = new test(2); // Creating a test object on the free store, and storing it in a pointer.

test ob(2); // Creating a test object, in stack memory (?)

I suspect only the first line creates an object in dynamic memory (and thus would have to be deallocated eventually by the programmer), while the second line only creates an object in stack memory due a lack of the keyword "new" (and would not have to be deallocated by the programmer).

HolyBlackCat
  • 78,603
  • 9
  • 131
  • 207
Inertial Ignorance
  • 525
  • 6
  • 24
  • 2
    Your understanding is correct. (Though some might argue that the standard doesn't mention the word 'stack' at all.) – HolyBlackCat Mar 19 '18 at 01:22
  • 1
    with your example the second one might either be allocated on stack or in static memory. Usually , if this is inside of a function, it is allocated on the stack, otherwise, in global scope, in static memory. – Serge Mar 19 '18 at 01:27
  • 1
    You can also use `malloc`, `calloc` and `realloc` to dynamically allocate memory. C++ also has a bunch of classes that wrap `operator new` and `operator new[]` such as `std::unique_ptr` and `std::shared_ptr`, there's almost never a need to directly use: `new`, `new[]`, `malloc`, `calloc` or `realloc` in modern C++. – George Mar 19 '18 at 01:29
  • In the first line, the object is not stored in a pointer. The object is stored in the free store. The pointer holds the address of the object in the free store. – M.M Mar 19 '18 at 01:45
  • Possible duplicate? At the very least, definitely worth reading. https://stackoverflow.com/questions/10157122/object-creation-on-the-stack-heap – Weak to Enuma Elish Mar 19 '18 at 02:04

1 Answers1

2

Your example is roughly correct.

test* pd = new test(2);

The new keyword will make the compiler allocate memory on the heap for a new test object. It is equivalent to calling malloc(size) in the C language. In languages (like C and C++) without an implicit garbage collector, you are then responsible for deleting the object later.

In some short-run programs you can get away with not deleting the object, since the memory allocated by the process should be freed when your process exits in a modern machine. But that's really inelegant and should not be your habit.

It is also important not to think of test*pd = new test(2); as storing a test object in the *pd pointer. The pointer is only pointing to it, and you can make the pointer point to other things later. The pointer has nothing to do with the new test object except that right now it happens to be pointing at it.

test ob(2);

Here, because you did not use the new keyword or otherwise allocate memory on the heap, the compiler is responsible for allocating the memory for the object--and for deleting it or forgetting about it when it falls out of scope. The stack is an ordinary way to do that, but I believe the method is technically compiler-dependent and there might be some cases where particular compilers stored the variable elsewhere.

Tom
  • 939
  • 5
  • 9