memory allocation for objects

Question

In C++, a variable like int x (which is a local variable because it is instantiated within a function) is allocated on top of the process stack.

However, if we use int *x=new int, heap space is made available.

 

So here are my inquiries:

So here are my inquiries:

1. What about objects belonging to several classes (user-defined or classes given by C++)?

Where do their things actually get created?

For instance:

Employee shall be a class, and Employee shall be declared emp;.

Empty spaces are either supplied on a stack or in a heap.

2.Do all four of the cells in int a[4] of a receive stack space if the declaration is contained within a function?

Answer 1

All local variables, whether they come from classes or built-in types or whether they are arrays, are on the stack.

On the heap, all dynamic allocations are made.

Naturally, applying a modifier like static to a local variable will cause the variable to be placed elsewhere, preserving it across function calls.

Additionally, to add to your confusion, if you establish a local pointer variable and set it to point to an object that was dynamically generated, for example

Class* a = new Class;

The memory that the variable a points to is on the heap, while the variable itself is on the stack.

Answer 2

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.