C++: Memory management (new / delete)

The operator new and operator delete functions are library global functions, which are encapsulations of malloc and free and do not call the constructor. and destructor.

If the application for space fails, an exception will be thrown directly, and the original malloc can only return 0.

/*
operator new: This function actually applies for space through malloc, and returns directly when malloc successfully applies for space; apply for space
If it fails, try to implement insufficient space countermeasures. If the countermeasures are set by the user, continue to apply, otherwise an exception will be thrown.
*/
void *__CRTDECL operator new(size_t size) __THROW1(__STD bad_alloc)
{<!-- -->
  // try to allocate size bytes
  void *p;
  while ((p = malloc(size)) == 0)
    if (_callnewh(size) == 0)
    {<!-- -->
      // report no memory
      // If the memory application fails, a bad_alloc type exception will be thrown here.
      static const std::bad_alloc nomem;
      _RAISE(nomem);
    }

  return(p);
}

/*
operator delete: This function finally releases space through free
*/
void operator delete(void *pUserData)
{<!-- -->
     _CrtMemBlockHeader * pHead;
     RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
     if (pUserData == NULL)
         return;
     _mlock(_HEAP_LOCK); /* block other threads */
     __TRY
         /* get a pointer to memory block header */
         pHead = pHdr(pUserData);
          /* verify block type */
         _ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
         _free_dbg(pUserData, pHead->nBlockUse);
     __FINALLY
         _munlock(_HEAP_LOCK); /* release other threads */
     __END_TRY_FINALLY
     return;
}
/*
implementation of free
*/
#define free(p) _free_dbg(p, _NORMAL_BLOCK)

The following three operations for dynamically allocating memory space for built-in types are the same.

int main()
{<!-- -->
  int* p1 = (int*)malloc(sizeof(int));
  free(p1);

  int* p2 = new int;
  delete(p2);

  int* p3 = (int*)operator new(sizeof(int));
  operator delete(p3);

  return 0;
}

Then the following code can also know how the underlying layer is called.

Stact* p1 = new Stack[10];
delete[](p1);

First, operator new is called to open up a space of 160 bytes. Then the constructor is called 10 times, creating 10 custom objects of the Stack class. Define type object.

However, through debugging, I found that it was not 160 bytes that were opened, but 168 bytes. The parameter sz of operator new was passed in. is 168

After the space is allocated, the value of p1 is 0x614c28. By observing 0x614c20, it is found that 8 more bytes have been allocated. Space, which stores the number of array elements 10

Replace the code, Stack* p1 = new Stack[8];
Found that the address pointed to by p1 is indeed 8 forward by 8

This number exists because the custom type has a destructor and you need to know how many times the destructor needs to be called.

At this time, if I mistakenly use delete instead of delete[], it will directly cause the program to crash. The program actually starts applying at 0x614c20 168 bytes of space. Using delete[] will automatically pass the address into operator delete, and delete will not be processed in this way, and the original 0x614c28 will be passed into the function. This address is not the first address of the applied space, and the release fails.

But if it is a built-in type, it may not crash

int* p2 = new int[10];
delete(p2);

Built-in types do not have destructors, so there is no need to open an extra space to record how many times the destructor needs to be called. In this way, the program will not crash.

Through the above debugging, you can get the following programming notes.

new/delete, new[]/delete[], malloc/free must be used together, otherwise the result will be undetermined.

5. Implementation principles of new and delete

1. Built-in types

If you are applying for a built-in type of space, new and malloc, delete and free are basically similar, with some differences. yes:
new/delete applies for and releases the space of a single element, while new[]/delete[] applies for and releases continuous space.
new will throw an exception when the application fails, and malloc will return NULL

2. Custom type

• The principle of new

  1. Call the operator new function to construct the space
  2. Execute the constructor on the requested space to complete the construction of the object

• The principle of delete

  1. Execute the destructor on the space to complete the cleanup of resources in the object
  2. Call the operator delete function to release the space of the object

• The principle of new[]

  1. Call the operator new[] function, and actually call the operator new function in operator new[] to complete the application for N object spaces.
  2. Execute the constructor N times on the allocated space

• The principle of delete[]

  1. Execute N destructors on the released object space to complete the cleanup of resources in N objects
  2. Call operator delete[] to release space. Actually call operator delete in operator delete[] to release space.

6. Positioning new expression (placement-new)

Positioning the new expression is to call the constructor to initialize an object in the allocated original memory space

Usage format:

new(place_address)type or new(place_address)type(initializer-list)

place_address must be a pointer and initializer-list is the type's initializer list.

scenes to be used:
The positioning new expression is generally used with the memory pool in practice. Because the memory allocated by the memory pool is not initialized, if it is a custom type object, you need to use new The definition expression explicitly calls the constructor for initialization.

class A
{<!-- -->
  public:
    A(int a = 0)
      :_a(a)
    {<!-- -->
      cout << "A():" <<this << endl;
    }

    ~A()
    {<!-- -->
      cout << "~A(): " <<this << endl;
    }

  private:
    int _a;
};

int main()
{<!-- -->
  A* p1 = (A*)malloc(sizeof(A)); // At this time, the space pointed to by p1 has not been initialized. Malloc only has the function of applying for space.
  new(p1)A; // Use positioning new to construct the p1 object
  p1->~A(); // The destructor can be called explicitly
  free(p1);

  A* p2 = (A*)operator new(sizeof(A)); // operator new also only applies for space and does not initialize the space
  new(p2)A(2); // Initialize using list
  p2->~A();
  operator delete(p2);

  return 0;
}

Finally, positioning new was indeed used to complete the initialization and construction of the uninitialized space.

7. The difference between malloc/free and new/delete

What malloc/free and new/delete have in common is that they both apply for space from the heap and require the user to release it manually.
The difference is:

1. malloc and free are functions, new and delete are operators.
2. The space requested by malloc will not be initialized, but new can be initialized.
3. When malloc applies for space, you need to manually calculate the space size and pass it. new only needs to be followed by the type of space. If there are multiple objects, [ ] Just specify the number of objects.
4. The return value of malloc is void*, which must be forced when used. new is not needed because new follows is the type of space.
5. When malloc fails to apply for space, it returns NULL, so it must be null when used. new is not required, but new code> needs to catch exceptions.
6. When applying for a custom type object, malloc/free will only open up space and will not call the constructor and destructor, while new will call the constructor after applying for space. Initialization of the object, delete will call the destructor to complete the cleanup of resources in the space before releasing the space.

End of this chapter.