0

So we have 2 main memories stack and heap. When I create an simple object of class(A obj) which is heap allocated and if we have data members which require heap allocation and stack allocation then what does actually happens? How much memory is allocated on heap while creating object and are stack allocated data members excluded from this heap allocation for object.

class A{
   public:

   int height;
   int * weight;

   A(){
     height=0;
     weight= new int(100);
   }
};

int main(){
  A *obj = new A(); // what's the memory allocation for object

  return 0;
}

My assumption is when we create heap allocated object then data members which require stack allocation are stack allocated and not counted for object's memory allocation on heap and other data members which require heap allocation are heap allocated and are consider for objects memory allocation. So in above allocation we only need 4bytes of heap memory as only have single data member which is pointer.

Improve this question
19
  • 1
    Please note that new int(100) creates one single int value, and initializes it to 100. Commented Dec 27, 2024 at 16:44
  • 2
    As for your question, because you use new A() all of the object data (its member variables) will be located on the heap. And on a modern 64-bit system a pointer is usually 64 bits, i.e. 8 bytes. Together with the int variable height (assuming a size of 4 bytes) and probable padding between the variables (for alignment), the size of your class should be 16 bytes. Commented Dec 27, 2024 at 16:45
  • 7
    Data members don’t get to choose where they are allocated. The memory for them has already been allocated when the memory for the containing object is allocated Commented Dec 27, 2024 at 16:51
  • 1
    Your code shouldn't really care about where object member variables are stored. Commented Dec 27, 2024 at 16:55
  • 1
    we have 2 main memories stack and heap. -- This is misunderstanding of the memory concept. The both member variables are located in A storage. One of them points to a heap allocated memory after initialization of A. See Member model Commented Dec 27, 2024 at 16:59

2 Answers 2

Reset to default
1

That is a really good question. The initialization in C++ is the most complicated topic, so do not hesitate to ask questions. Even experienced developers may misunderstand some concepts.

There are no heap data members or stack data members. All the data members inside the class are allocated one by one close to each other's in the order as they are declared in the class.

What you are missing are the pointers. Pointer is similar to the unsigned int data type. It occupies 4 bytes on the 32-bit platform and 8 bytes on the 64-bit platform regardless of the data size it points to. You may think of memory as an array of bytes and pointer is an index to the array.

In order to construct the object you need a storage. You may think of storage as a region in the memory. What is the size of the object? The answer is sizeof(A). On 64 bit platform sizeof(A) == 16

  • 4 bytes for the int variable
  • 4 bytes padding (google it)
  • 8 bytes for the pointer to int

The storage is an addressable memory you can get a pointer:

  • Platform neutral

    • static storage (global variables)
    • dynamic storage (heap)
    • automatic storage (stack)
    • thread local storage

  • Platform specific

    • memory mapped files
    • shared memory
    • maybe more, depends on platform

So when you construct the object on the stack, the compiler allocates the required amount of memory on the stack and invokes the class constructor.

When you construct the object on the heap using the operator new, the compiler invokes a malloc-like function to allocate some amount of the memory on the heap and then it invokes the class constructor.

In case if object is allocated on the stack, compiler ensures it is destroyed once you return from the function (or leave the scope they say). The same behavior is for the objects allocated on the static storage.

In case if object is allocated on the heap, it is developer's responsibility to destroy the object and release the memory.

In your case you perform two allocations on the heap:

  1. One is for the class A object
  2. Another one is for the int

Because you never call operator delete the objects you're created are never released. That is a memory leak.

Improve this answer
Sign up to request clarification or add additional context in comments.

8 Comments

The terms "heap" and "stack" are not platform-neutral. In fact, those terms (referring to areas of memory) originated in context of a particular platform, and referred to physically different areas of memory (i.e. on physical memory chips/circuits). The platform neutral counterparts of "heap" and "stack" are "dynamically allocated memory" "variables of automatic storage duration". Some commonly used implementations (compilers and libraries) default to placing dynamically allocated memory in "heap" and automatic variables (and also static variables, incidentally) in "stack".
the operator new, the compiler invokes malloc() This is not true, this is one of possible but not the only implementation detail.
malloc to allocate some amount of the memory on the stack This is usually unlikely true,
@Peter: The platform neutral counterparts of "heap" and "stack" are "dynamically allocated memory" "variables of automatic storage duration": Fixed. thanks
@3CxEZiVlQ: the compiler invokes malloc() This is not true, this is one of possible but not the only implementation detail: Do you want to explain this guy all the edge cases now?
|
0

So we have 2 main memories stack and heap

That's a silly thing to say, you just have memory. Be it from single or multiple RAM sticks, L* CPU caches, disk backed memory mapped files, swap files, tape, it's all memory. And the correct name for it is virtual memory in modern operating systems. Whether you choose to name parts of it "stack" or "heap" or "kittens", that's your choice.

So in above allocation we only need 4bytes of heap memory as only have single data member which is pointer.

No, you have sizeof(A) (probably) equal to 2 * sizeof(int). On a 32-bit Intel system, that's (probably) 8 bytes. That's how much memory is allocated by the new operator when called with A.

weight= new int(100);

Unrelated to your question, but that most likely doesn't do what you think it does. It doesn't allocate an array of 100 int items, it allocates one int and initializes it to 100.

What about member functions where are they stored?

Functions are code, and code is stored in the text segment of your executable. It is then mapped to virtual memory by the OS executable loader and memory manager, allowing pointers to reference it.

Virtual member functions are different, a pointer to them is stored in a hidden allocation inside your class allocation. Did you happen to see all those "probably" above? The virtual function table is one reason for those, it makes the allocation larger than it would seem to be.

Improve this answer

4 Comments

The C++ standard has automatic variables (stack), dynamically allocated variables (heap) and a third category you missed: variables with static storage duration (global).
@RaymondChen Those aren't locations in memory. The C++ standard has automatic, dynamic, static, and thread (which you missed) storage durations. The standard defines how long the storage must endure, but it's up to the implementation to decide where that storage lives. Case in point: inside a co-routine, a variable with automatic storage duration may very well live in heap memory so that the co-routine can suspend.
The standard says nothing about where in memory these objects exist. The distinctions between stack, heap, and global is an implementation detail (though a detail that most implementations agree on). There might be some confusion in the original question over what is part of the language and what is part of the implementation.
That is exactly what I said, stack/heap are implementation details, and very fluid ones (the coroutine example above).

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.