How does delete know it s an array

Question

Alright  I think we all agree that what happens with the following code is undefined  depending on what is passed   void deleteForMe int  pointer         delete   pointer      The pointer could be all sorts of different things  and so performing an unconditional delete   on it is undefined  However  let s assume that we are indeed passing an array pointer   int main          int  arr   new int 5        deleteForMe arr        return 0      My question is  in this case where the pointer is an array  who is it that knows this  I mean  from the language compiler s point of view  it has no idea whether or not arr is an array pointer versus a pointer to a single int  Heck  it doesn t even know whether arr was dynamically created  Yet  if I do the following instead   int main          int  num   new int 1        deleteForMe num        return 0      The OS is smart enough to only delete one int and not go on some type of  killing spree  by deleting the rest of the memory beyond that point  contrast that with strlen and a non- 0-terminated string -- it will keep going until it hits 0    So whose job is it to remember these things  Does the OS keep some type of record in the background   I mean  I realise that I started this post by saying that what happens is undefined  but the fact is  the  killing spree  scenario doesn t happen  so therefore in the practical world someone is remembering

User · Answer

One question that the answers given so far don't seem to address: if the runtime libraries (not the OS, really) can keep track of the number of things in the array, then why do we need the delete[] syntax at all? Why can't a single delete form be used to handle all deletes?

The answer to this goes back to C++'s roots as a C-compatible language (which it no longer really strives to be.) Stroustrup's philosophy was that the programmer should not have to pay for any features that they aren't using. If they're not using arrays, then they should not have to carry the cost of object arrays for every allocated chunk of memory.

That is, if your code simply does

Foo* foo = new Foo;

then the memory space that's allocated for foo shouldn't include any extra overhead that would be needed to support arrays of Foo.

Since only array allocations are set up to carry the extra array size information, you then need to tell the runtime libraries to look for that information when you delete the objects. That's why we need to use

delete[] bar;

instead of just

delete bar;

if bar is a pointer to an array.

For most of us (myself included), that fussiness about a few extra bytes of memory seems quaint these days. But there are still some situations where saving a few bytes (from what could be a very high number of memory blocks) can be important.

User · Answer

Agree that the compiler doesn t know if it is an array or not  It is up to the programmer    The compiler sometimes keep track of how many objects need to be deleted by over-allocating enough to store the array size  but not always necessary    For a complete specification when extra storage is allocated  please refer to C   ABI  how compilers are implemented   Itanium C   ABI  Array Operator new Cookies

User · Answer

This is very similar to this question and it has many of the details your are looking for    But suffice to say  it is not the job of the OS to track any of this   It s actually the runtime libraries or the underlying memory manager that will track the size of the array   This is usually done by allocating extra memory up front and storing the size of the array in that location  most use a head node      This is viewable on some implementations by executing the following code  int  pArray   new int 5   int size     pArray-1

User · Answer

I had a similar question to this  In C  you allocate memory with malloc    or another similar function   and delete it with free    There is only one malloc    which simply allocates a certain number of bytes  There is only one free    which simply takes a pointer as it s parameter   So why is it that in C you can just hand over the pointer to free  but in C   you must tell it whether it s an array or a single variable   The answer  I ve learned  has to do with class destructors   If you allocate an instance of a class MyClass     classes   new MyClass 3     And delete it with delete  you may only get the destructor for the first instance of MyClass called  If you use delete    you can be assured that the destructor will be called for all instances in the array   THIS is the important difference  If you re simply working with standard types  e g  int  you won t really see this issue  Plus  you should remember that behavior for using delete on new   and delete   on new is undefined--it may not work the same way on every compiler system

User · Answer

quot undefined behaviour quot  simply means the language spec makes no gaurantees as to what will happen  It doesn t nessacerally mean that something bad will happen   So whose job is it to remember these things  Does the OS keep some type of record in the background   I mean  I realise that I started this post by saying that what happens is undefined  but the fact is  the  killing spree  scenario doesn t happen  so therefore in the practical world someone is remembering    There are typically two layers here  The underlying memory manager and the C   implementation  Most memory managers were designed to meet the needs of the C language  In C the  quot free quot  function does not require the user to specify the size of the block  Therefore the memory manager will remember  among other things  the size of the block of memory that was allocated  This may be larger than the block the C   implementation asked for  Typically the memory manager will store it s metadata before the allocated block of memory  C   has a culture of  quot you only pay for what you use quot   Therefore the C   implementation will generally only remember the size of the array if it needs to do so for it s own purposes  typically because the type has a non-trival destructor  So for types with a trivial destructor the implementation of  quot delete quot  and  quot delete    quot  is typically the same  The C   implementation simply passes the pointer to the underlying memory manager  Something like free p   On the other hand for types with a non-trivial destructor  quot delete quot  and  quot delete    quot  are likely to be different   quot delete quot  would be somthing like  where T is the type that the pointer points to  p- gt  T    free p    While  quot delete    quot  would be something like  size t   pcount     size t   p -1  size t count    count  for  size t i 0 i lt count i        p i   T      char   pmemblock     char   p  - max sizeof size t  alignof T    free pmemblock

User · Answer

ONE OF THE  approaches for compilers is to allocate a little more memory and store count of elements in the head element    Example how it could be done  Here  int  i   new int 4     compiler will allocate sizeof int  5 bytes   int  temp   malloc sizeof int  5    Will store 4 in first sizeof int  bytes   temp   4    and set i  i   temp   1    So i points to array of 4 elements  not 5   And  delete   i    will be processed following way  int  temp   i - 1  int numbers of element    temp       4     call destructor for numbers of element elements if needed     that are stored in temp   1  temp   2      temp   4 free  temp

User · Answer

just define a destructor inside a class and execute your code with both syntax  delete pointer  delete    pointer   according to the output u can find the solutions

User · Answer

The compiler doesn t know it s an array  it s trusting the programmer   Deleting a pointer to a single int with delete    would result in undefined behavior   Your second main   example is unsafe  even if it doesn t immediately crash   The compiler does have to keep track of how many objects need to be deleted somehow   It may do this by over-allocating enough to store the array size   For more details  see the C   Super FAQ

User · Answer

Semantically  both versions of delete operator in C   can  eat  any pointer  however  if a pointer to a single object is given to delete    then UB will result  meaning anything may happen  including a system crash or nothing at all   C   requires the programmer to choose the proper version of the delete operator depending on the subject of deallocation  array or single object   If the compiler could automatically determine whether a pointer passed to the delete operator was a pointer array  then there would be only one delete operator in C    which would suffice for both cases

User · Answer

It s up to the runtime which is responsible for the memory allocation  in the same way that you can delete an array created with malloc in standard C using free  I think each compiler implements it differently  One common way is to allocate an extra cell for the array size    However  the runtime is not smart enough to detect whether or not it is an array or a pointer  you have to inform it  and if you are mistaken  you either don t delete correctly  E g   ptr instead of array   or you end up taking an unrelated value for the size and cause significant damage

User · Answer

delete or delete   would probably both free the memory allocated  memory pointed   but the big difference is that delete on an array won t call the destructor of each element of the array   Anyway  mixing new new   and delete delete   is probably UB

User · Answer

Yes  the OS keeps some things in the  background    For example  if you run  int  num   new int 5     the OS can allocate 4 extra bytes  store the size of the allocation in the first 4 bytes of the allocated memory and return an offset pointer  ie  it allocates memory spaces 1000 to 1024 but the pointer returned points to 1004  with locations 1000-1003 storing the size of the allocation    Then  when delete is called  it can look at 4 bytes before the pointer passed to it to find the size of the allocation   I am sure that there are other ways of tracking the size of an allocation  but that s one option

User · Answer

Hey ho well it depends of what you allocating with new   expression when you allocate array of build in types or class   structure and you don t provide your constructor and destructor the operator will treat it as a size  sizeof object  numObjects  rather than object array therefore in this case number of allocated objects will not be stored anywhere  however if you allocate object array and you provide constructor and destructor in your object than behavior change  new expression will allocate 4 bytes more and store number of objects in first 4 bytes so the destructor for each one of them can be called and therefore new   expression will return pointer shifted by 4 bytes forward  than when the memory is returned the delete   expression will call a function template first  iterate through array of objects and call destructor for each one of them  I ve created this simple code witch overloads new   and delete   expressions and provides a template function to deallocate memory and call destructor for each object if needed      overloaded new expression  void  operator new    size t size            allocate 4 bytes more see comment below      int  ptr    int  malloc  size   4            set value stored at address to 0         and shift pointer by 4 bytes to avoid situation that        might arise where two memory blocks         are adjacent and non-zero      ptr   0        ptr        return ptr                                                   overloaded delete expression  void static operator delete    void  ptr            decrement value of pointer to get the         Real Pointer Value      int  realPtr    int  ptr      --realPtr       free  realPtr                                                     Template used to call destructor if needed     and call appropriate delete  template lt class T gt  void Deallocate  T  ptr         int  instanceCount    int  ptr      --instanceCount       if  instanceCount  gt  0     if larger than 0 array is being deleted                  call destructor for each object         for int i   0  i  lt   instanceCount  i                          ptr i   T                         call delete passing instance count witch points            to begin of array memory            operator delete    instanceCount              else                  single instance deleted call destructor            and delete passing ptr         ptr- gt  T              operator delete    ptr                Replace calls to new and delete  define MyNew   new  define MyDelete ptr  Deallocate ptr      structure with constructor  destructor struct StructureOne       StructureOne        someInt 0              StructureOne                  someInt   0             int someInt                                        structure without constructor  destructor struct StructureTwo       int someInt                                      void main void        const unsigned int numElements   30       StructureOne  structOne   nullptr      StructureTwo  structTwo   nullptr      int  basicType   nullptr      size t ArraySize   0                                                                                   basic type array          place break point here and in new expression        check size and compare it with size passed         in to new expression size will be the same     ArraySize   sizeof  int     numElements          this will be treated as size rather than object array as there is no         constructor and destructor  value assigned to basicType pointer        will be the same as value of    ptr  in new expression     basicType   MyNew int numElements           Place break point in template function to see the behavior        destructors will not be called and it will be treated as         single instance of size equal to  sizeof  int     numElements      MyDelete  basicType                                                                                     structure without constructor and destructor array          behavior will be the same as with basic type          place break point here and in new expression        check size and compare it with size passed         in to new expression size will be the same     ArraySize   sizeof  StructureTwo     numElements          this will be treated as size rather than object array as there is no         constructor and destructor value assigned to structTwo pointer        will be the same as value of    ptr  in new expression     structTwo   MyNew StructureTwo numElements            Place break point in template function to see the behavior        destructors will not be called and it will be treated as         single instance of size equal to  sizeof  StructureTwo     numElements      MyDelete  structTwo                                                                                     structure with constructor and destructor array          place break point check size and compare it with size passed in        new expression size in expression will be larger by 4 bytes     ArraySize   sizeof  StructureOne     numElements          value assigned to  structOne pointer  will be different         of    ptr  in new expression   shifted by another 4 bytes      structOne   MyNew StructureOne numElements           Place break point in template function to see the behavior        destructors will be called for each array object      MyDelete  structOne

User · Answer

It doesn t know it s an array  that s why you have to supply delete   instead of regular old delete

User · Answer

You cannot use delete for an array  and you cannot use delete    for a non-array

User · Answer

The answer   int  pArray   new int 5    int size     pArray-1    Posted above is not correct and produces invalid value   The  -1 counts elements On 64 bit Windows OS the correct buffer size resides in Ptr - 4 bytes address

[c++] How does delete[] know it's an array?

Examples related to c++

Examples related to arrays

Examples related to pointers

Examples related to new-operator

Examples related to delete-operator