How to cleared off the whole memory for the unused array allocated on the heap

Question

I have some question about the delete[] p. I've written some code snippet for test this function. But I found that after executing the delete[] p, only the first 2 array elements were deallocated while the remaining not. Please see my test snippet and the output result as below. Who can tell me why and how can I clear off the whole memory for the unused array? Thanks!

#include <iostream>
using namespace std;
int main()
{
   int *p;
   p = new int[20];
   for(int i=0;i<20;i++)
   {
       p[i]=i+1;
   }
    cout<<"------------------------Before delete-------------------------"<<endl;
    for(int i=0;i<20;i++)
   {
       cout<<"p+"<<i<<":"<<p+i<<endl;
       cout<<"p["<<i<<"]:"<<p[i]<<endl;
   }

    delete[] p;
        cout<<"-------------------After delete------------------------"<<endl;
    for(int i=0;i<20;i++)
   {
       cout<<"p+"<<i<<":"<<p+i<<endl;
       cout<<"p["<<i<<"]:"<<p[i]<<endl;
   }
   return 0; 
}

OUTPUT IN www.compileronline.com

Compiling the source code....
$g++ main.cpp -o demo -lm -pthread -lgmpxx -lgmp -lreadline 2>&1


Executing the program....
$demo

------------------------Before delete-------------------------
p+0:0xa90010
p[0]:1
p+1:0xa90014
p[1]:2
p+2:0xa90018
p[2]:3
p+3:0xa9001c
p[3]:4
p+4:0xa90020
p[4]:5
p+5:0xa90024
p[5]:6
p+6:0xa90028
p[6]:7
p+7:0xa9002c
p[7]:8
p+8:0xa90030
p[8]:9
p+9:0xa90034
p[9]:10
p+10:0xa90038
p[10]:11
p+11:0xa9003c
p[11]:12
p+12:0xa90040
p[12]:13
p+13:0xa90044
p[13]:14
p+14:0xa90048
p[14]:15
p+15:0xa9004c
p[15]:16
p+16:0xa90050
p[16]:17
p+17:0xa90054
p[17]:18
p+18:0xa90058
p[18]:19
p+19:0xa9005c
p[19]:20
-------------------After delete------------------------
p+0:0xa90010
p[0]:0
p+1:0xa90014
p[1]:0
p+2:0xa90018
p[2]:3
p+3:0xa9001c
p[3]:4
p+4:0xa90020
p[4]:5
p+5:0xa90024
p[5]:6
p+6:0xa90028
p[6]:7
p+7:0xa9002c
p[7]:8
p+8:0xa90030
p[8]:9
p+9:0xa90034
p[9]:10
p+10:0xa90038
p[10]:11
p+11:0xa9003c
p[11]:12
p+12:0xa90040
p[12]:13
p+13:0xa90044
p[13]:14
p+14:0xa90048
p[14]:15
p+15:0xa9004c
p[15]:16
p+16:0xa90050
p[16]:17
p+17:0xa90054
p[17]:18
p+18:0xa90058
p[18]:19
p+19:0xa9005c
p[19]:20

Answer 1

It is important to distinguis between cleared memory and deleted memory.

When memory is cleared it is initialized to some value - perhaps all zeros. But when memory is deleted or freed, it is returned to the heap. When the memory is released the memory manager is under no obligation to clear the memory. The two bytes you see being changed are likely from a debug marker used by the memory manager to help track buffer overruns.

If you want to clear all of the memory, you need to do it before you delete it - only at that point do you still have ownership of that memory. Clearing it after deleting it is operating on memory you do not own.

Answer 2

The memory is cleared - there's just no requirement that the compiler will actually zero out an int in its destructor. What you're seeing is that the compiler didn't think that was necessary, so it's still there. The destructor is called though and the memory is freed.

You can see that more clearly if you did something like:

struct A {
    int i;
    A() : i(7) { }

    ~A() {
        std::cout << "deleting A." << std::endl;
        i = 0;
    }
};

And repeat your experiment with A* p = new A[20];.