Is my data stored in heap or in stack in below code

Question

In the below code, I get memory through malloc and pointed it by pointer ptr. When I assigned value as shown I stored the data in pointer and we know that pointer is located in stack frame.

So my question is: My data(integers) is stored in stack or in heap?

#include<stdio.h>
#include<stdlib.h>
void main()
{
  int *ptr;
  ptr=(int*)malloc(5*sizeof(int));
  ptr[0]=5;
  ptr[1]=6;
  ptr[2]=8;
  ptr[3]=10;
  ptr[4]=11;
}

Answer 1

Yes, the pointer is stored on the stack, but the memory it points to is on the heap. Therefore, the integers are stored on the heap.

---

Edit to answer the question from the comments:

Why we didn't use * like *ptr[0]=5; this means 5 store at the location where ptr[0] is pointing So, my question is why we didn't use *before ptr

In C, an array access is defined in terms of pointers. So the array element access ptr[0] can be written as *ptr. To access element n of the array, you can write ptr[n] or *(ptr+n).

You would use *ptr[0] if your array stored pointers and you wanted to access the value. You can also think of that as a two-dimensional array. In other words, *ptr[0] is equivalent to ptr[0][0].

From the C standard:

A postfix expression followed by an expression in square brackets [] is a subscripted designation of an element of an array object. The definition of the subscript operator [] is that E1[E2] is identical to (*((E1)+(E2))). Because of the conversion rules that apply to the binary + operator, if E1 is an array object (equivalently, a pointer to the initial element of an array object) and E2 is an integer, E1[E2] designates the E2-th element of E1 (counting from zero).

Also see this question: Is an array name a pointer?

Answer 2

Pedantically speaking, from the perspective of the C standard, all the objects involved here simply occupy some memory that is suitably aligned, and disjointed from other objects.

While the notion of a stack and heap are commonplace, the C standard makes no reference to either terms. How and where data is stored is mostly implementation-defined.

The principle thing differentiating them is their visibility and effective lifetimes (see: Storage duration, Lifetime, and Scope):

• The use of ptr is valid until main returns.

• The use of the memory at the address returned by malloc is valid until it is deallocated.

---

Practically speaking, however, it is generally fair to refer to objects with

• automatic storage duration as existing on the "stack",
• static storage duration as existing in the "data segment", and
• allocated storage duration as existing on the "heap",

as this a very common way C implementations work.

With this terminology, the object designated by the identifier ptr exists on the stack, and the objects accessed via the pointer returned by malloc exist on the heap.