So I think you’re working from a false premise.

I believe you assume that if there are non-zero values in the memory space that was just allocated that the memory was somehow not properly allocated. And that’s a horrific assumption that’s going to burn you badly later on as you build more complex programs. Suffice it to say that the memory is being properly allocated, but you’re misinterpreting what you got back.

Neither C nor C++ guarantee that allocated memory will be initialized. Initialized memory (and variables) is memory or variables that are set to a specific value (typically 0, “”, or false) when the variable is declared or the memory is allocated.

So this is where I think you have a false premise. I believe you’re looking at the contents of the recently allocated variable; seeing non-zero values; and assuming the allocation went wrong.

Complicating your observations is the two approaches you are using to allocate memory.

int myArray[10];  // allocates on stack

int *myPointer;
myPointer = malloc(10*sizeof(int));  // allocates on heap

As pointed out in the comments, one approach allocates on the stack and the other allocates from the heap.

Allocating from the stack will be more likely to reuse memory space that’s been used and released! by another area so the memory won’t show up as initialized.

Allocating from the heap is probably less likely to reuse space that’s already been used and released as it’s a larger area of memory to pull from. And there’s a distinctly possibility that you’re forgetting to free your memory after allocating it, so you wouldn’t run into any reuse cases.

Regardless of all that, the correct thing to do in C and C++ is to initialize all memory and variables prior to using it. Get into the habit of immediately calling memset after you allocate your memory.

This looks like a Stack Overflow (hehe).

When you allocate on the stack, there are other entities present surrounding the allocated array (in the memory with an address immediately larger than the array). Since you said in your comment “after few iterations the value of n suddenly changes to something garbage” I assume that n is declared in your code after the array:

int array[10];
...
int n;

Not before the array:

int n;
...
int array[10];

This doesn’t look like a “proper memory allocation” issue, but accessing the array with an invalid index, and writing in overflow. I think your memory corruption is present when you use malloc as well, but since you do not have memory allocated right after the array (when using malloc), the memory corruption affects areas of unallocated memory (and this is not visible to you).

Here’s an example of overflow (and a wild guess on my part):

You say you allocate array of n*n elements and iterate from 0 to n*n - 1. Are you sure? If you use two imbricated for loops, do not do this:

for(int i = 0; i <=n; ++i) // this is incorrect
    for(int j = 0; j < n; ++j)
        // access at i, j

This doesn’t iterate n*n, but [(n+1) * n] - 1 (and would cause an overflow).