Does this type of memory get allocated on the heap

Question

In the context of C++ (not that it matters):

class Foo{
    private:
        int x[100];
    public:
        Foo();
}

What I've learnt tells me that if you create an instance of Foo like so:

Foo bar = new Foo();

Then the array x is allocated on the heap, but if you created an instance of Foo like so:

Foo bar;

Then it's created on the stack.

I can't find resources online to confirm this.

Answer 1

Strictly speaking, according to the standard the object need not exist on a stack or heap. The standard defines 3 types of 'storage duration', but doesn't state exactly how the storage must be implemented:

1. static storage duration
2. automatic storage duration
3. dynamic storage duration

Automatic storage duration is typically (nearly always) implemented using the stack.

Dynamic storage duration is typically implemented using the heap (ultimately via malloc()), though this can be overridden even by the compiler's user.

Static storage duration is what it typically known as globals (or static storage).

The standard has this to say about these things (the following are excerpts form various bits of 3.7 - Storage Duration):

Static and automatic storage durations are associated with objects introduced by declarations (3.1) and implicitly created by the implementation (12.2). The dynamic storage duration is associated with objects created with operator new (5.3.4).

...

All objects which neither have dynamic storage duration nor are local have static storage duration. The storage for these objects shall last for the duration of the program (3.6.2, 3.6.3).

...

Local objects explicitly declared auto or register or not explicitly declared static or extern have automatic storage duration. The storage for these objects lasts until the block in which they are created exits.

...

Objects can be created dynamically during program execution (1.9), using new-expressions (5.3.4), and destroyed using delete-expressions (5.3.5). A C + + implementation provides access to, and management of, dynamic storage via the global allocation functions operator new and operator new[] and the global deallocation functions operator delete and operator delete[].

...

The library provides default definitions for the global allocation and deallocation functions. Some global allocation and deallocation functions are replaceable (18.4.1)

And finally (regarding the array in your example class):

3.7.4 Duration of sub-objects [basic.stc.inherit]

The storage duration of member subobjects, base class subobjects and array elements is that of their complete object (1.8).

Answer 2

An object of type Foo takes the size of 100 ints stored in sequence. If you create it on the stack, you will be getting it all on the stack. If you do it with new, it'll be on the heap as part of the object.

This is part of the language specification, I'm not sure what your question is.

Answer 3

Yes, the member array x will be created on the heap if you create the Foo object on the heap. When you allocate dynamic memory for Foo you are asking for memory of length sizeof(Foo) (plus possibly some memory overhead, but let's ignore that for the time being), which in your sample code implies the size of 100 ints. This has to be case for the lifespan of objects of type Foo (and their internal data) to cross scopes.

If you don't create the Foo object on the heap, and the internal array of Foo isn't a pointer to which you allocate memory with new in Foo's constructor then that internal array will be created on the stack. Again, this has to be the case in order for the array to automatically be cleaned without any deletes when the scope ends. Specifically,

struct Foo {
    int* y;
    Foo() : y(new int()) { }
    ~Foo() { delete y; }
};

will create y on the heap regardless of whether a Foo object was created on the stack or on the heap.

Answer 4

You mean

Foo* bar = new Foo(); 

I suppose. That is created in the heap.

Answer 5

Given a slight modification of your example:

class Foo{
    private:
        int x[100];
        int *y;
    public:
        Foo()
        {
           y = new int[100];
        }
        ~Foo()
        { 
           delete[] y; 
        }

}

Example 1:

Foo *bar = new Foo();

• x and y are on the heap:
• sizeof(Foo*) is created on the stack.
• sizeof(int) * 100 * 2 + sizeof(int *) is on the heap

---

Example 2:

Foo bar;

• x is on the stack, and y is on the heap
• sizeof(int) * 100 is on the stack (x) + sizeof(int*)
• sizeof(int) * 100 is on the heap (y)

Actual sizes may differ slightly due to class/struct alignment depending on your compiler and platform.