memory allocation for objects

Question

When we instantiate a variable in c++ like int x within a function(i.e. x is a local variable), it is allocated on top of stack of the process. But if we do int *x= new int, the space is provided in heap.

So, my questions are:

What about objects of different classes (classes provided by c++ or user defined)? Where are their objects instantiated? For example: Let Employee is a class and we declare Employee emp;. Where is emp given space-> on stack or in heap?
If the declaration int a[4] is within a function, do all the four cells of a get space on stack?

I'd like to mention that `new`, if not overloaded, allocates space in the so-called free store, which isn't necessarily the heap, although in practice it is. If it **is** overloaded, `new` can do anything. — Alex, Feb 06 '13 at 08:27

Some programmer dude · Answer 1 · 2014-11-15T12:07:39.827

All local variables, no matter if from built-in types of from classes, or if they are arrays, are on the stack. All dynamic allocations are on the heap.

Of course, modifiers like static on a local variable will make the variable be put somewhere else, so it's preserved between function calls.

Also, to confuse you further, when you create a local pointer variable, and make it point to a dynamically allocated object, e.g.

Class* a = new Class;

The actual variable a is on the stack, but the memory it points to is on the heap.

Addendum: The C++ specification doesn't actually mention anything about stack or heap, only the behavior of different kind of variables.

SingerOfTheFall · Answer 2 · 2013-02-06T08:28:38.177

7

It's exactly the same as with normal types.

Class a; //stack. Usage: a.somethingInsideOfTheObject
Class *a = new Class(); //heap. Usage: a->somethingInsideOfTheObject

Note that if the class itself is allocating something on the heap, that part will always be on the heap, for example:

class MyClass
{
public:
    MyClass()
    {
        a = new int();
    }
private:
    int * a;
};

void foo()
{
    MyClass bar;
}

in this case the bar variable will be allocated on the stack, but the a inside of it will be allocated on the heap.

edited Feb 06 '13 at 08:28

answered Feb 06 '13 at 08:18

SingerOfTheFall

29,228
8
68
105

1

It might be worth noting that if `Class` makes use of `new` internally, that always uses the heap, even if `a` itself lives on the stack. – NPE Feb 06 '13 at 08:19
@NPE, true, but as long as you treat them as black boxes, you will hardly know it – SingerOfTheFall Feb 06 '13 at 08:22
1

@SingerOfTheFall - true, bit it's still an important detail. – Kiril Kirov Feb 06 '13 at 08:23
@meh, ok, I've added it to my answer – SingerOfTheFall Feb 06 '13 at 08:28
@SingerOfTheFall: The reason I thought this detail was important is that if someone places a `std:vector` on the stack, they shouldn't be expecting the contents of the vector to go on the stack. – NPE Feb 06 '13 at 08:37

score 4 · Accepted Answer · answered Feb 06 '13 at 08:19

It depends. If Employee has members, that are allocated only on the stack, then the whole object is. BUT, Employee may have pointer members and Employee's constructor may allocate memory for them on the heap. Then some of the members are on the heap, some on the stack.
Yes.

score 3 · Answer 4 · answered Feb 06 '13 at 08:21

User defined classes (and types) are no different than built-in types. So

Employee emp; // allocated in stack
Employee* emp = new Employee(); // allocated in heap

As for your second question, local arrays are allocated on stack

Employee emp[4]; // 4 instances on stack

score 1 · Answer 5 · edited May 23 '17 at 11:52

1

Generally, if the compiler knows about it at compile time (i.e. local variables), it's on the stack.
If the compiler doesn't know about it at compile time (i.e. dynamic allocation via new, malloc etc), it's on the heap.

This post has a detailed explanation: global-memory-management-in-c-in-stack-or-heap

edited May 23 '17 at 11:52

Community

1
1

answered Feb 06 '13 at 08:23

parrowdice

1,902
15
24

memory allocation for objects

5 Answers5

Linked