Memory Allocation for Derived C++ classes

Question

I am working on designing a small system and am wondering about a nuance of how memory is allocated for derived classes.

If I have two classes

class foo {
public: int a;
Foo(): a(0) {};
 };
class bar : public foo {
public: int b;
Bar() : Foo() , b(0) {}
};

and then do something like this in another method

Bar* purple = new Bar();

I know that both constructors will be called (for Foo and Bar) but how will the memory be allocated. Is the memory for both 'a' and 'b' allocated at the same time, as they are both a part of Bar class, or is the memory allocated for 'a' when the Foo constructor is called and the memory for 'b' allocated when the Bar constructor is called.

Thanks in advance for the help.

As an aside you should be using initializer syntax instead of assigning a and b in the body of the constructor. — Kate Gregory, Oct 19 '11 at 21:09
Kate Gregory: Whoops, thank you for the heads up, should be fixed now @Chad Thanks for the help — Adam, Oct 19 '11 at 21:14

score 2 · Answer 1 · answered Oct 19 '11 at 21:14

2

The sizeof(bar) is sufficiently large such that it can contain sizeof(foo) and everything is allocated in once allocation request.

answered Oct 19 '11 at 21:14

Martin York

257,169
86
333
562

score 2 · Accepted Answer · edited May 23 '17 at 12:27

new Bar is just one contiguous allocation, as is new Bar[n].

It may help to think of like this:

Bar* purple = new Bar();

is similar to:

Bar* purple = (Bar*)malloc(sizeof(Bar));

Behind the scenes, the constructor is also called, and in some cases the allocation may be greater than sizeof(Bar); new[] is a common case where it is greater because the array's count is secretly stored in the allocation in many implementations.

Update

The sizeof Bar itself is the size required to store the type; its members, its bases, a pointer to its vtable, etc. - all with native alignment (by default). The compiler may also introduce padding.

Therefore, the single contiguous allocation will be sufficiently large enough to hold everything both foo and bar require, including foo::a and bar::b.

In more detail: where are member-vars of a class on the heap stored?

It should also be clarified that since `Bar` inherits from `foo`, it has all the members and functions that `foo` has, so that's why `sizeof(Bar)` is guaranteed to be big enough. — Mooing Duck, Oct 19 '11 at 21:23

Memory Allocation for Derived C++ classes

2 Answers2