> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # C++ Deallocation The `delete` operator is a unary operator used to deallocate memory that was previously allocated dynamically on the free store (heap) using the `new` operator. It destroys the object at the specified memory address and returns the memory to the system, preventing memory leaks. ## Syntax The operator has two distinct forms depending on how the memory was originally allocated: ```cpp theme={"dark"} // Scalar form: Deallocates memory for a single object delete pointer; // Array form: Deallocates memory for an array of objects delete[] pointer; ``` ## Execution Mechanics When the `delete` operator is invoked, it executes a strict two-step process: 1. **Destruction:** It invokes the destructor of the object (or, in the case of `delete[]`, the destructors of every object in the array in reverse order of their construction). This allows the object to safely release any internal resources. 2. **Deallocation:** It calls the underlying memory deallocation function (`operator delete` or `operator delete[]`) to return the raw memory bytes to the free store. ## Technical Rules and Undefined Behavior To maintain memory safety, the `delete` operator is governed by strict rules. Violating these rules typically results in undefined behavior (UB): * **Null Pointers:** Applying `delete` or `delete[]` to a `nullptr` is a guaranteed no-operation. It is inherently safe and requires no explicit null-check prior to invocation. * **Form Matching:** The scalar `delete` must strictly pair with the scalar `new`. The array `delete[]` must strictly pair with the array `new[]`. Mismatching these forms (e.g., using `delete` on a pointer allocated with `new[]`) causes UB. * **Double Free:** Invoking `delete` on a memory address that has already been deallocated results in UB. * **Non-Dynamic Memory:** Applying `delete` to a pointer referencing memory not allocated by `new` (such as stack-allocated variables or statically allocated memory) results in UB. * **Polymorphic Deletion:** If `delete` is applied to a base class pointer that points to a derived class object, the base class *must* have a `virtual` destructor. If the base class destructor is not virtual, the invocation results in UB (typically failing to call the derived class's destructor, resulting in resource leaks). * **Incomplete Types:** Applying `delete` to a pointer of an incomplete class type results in UB if the fully defined class ultimately possesses a non-trivial destructor or a class-specific `operator delete`. ## Dangling Pointers After the `delete` operator completes execution, the pointer variable itself continues to exist in its current scope and retains the now-invalid memory address. This is known as a dangling pointer. Dereferencing a dangling pointer results in UB. ```cpp theme={"dark"} int* ptr = new int(5); delete ptr; // ptr is now a dangling pointer. // ptr = nullptr; // Recommended practice to prevent accidental dereferencing ``` ## Overloading `operator delete` While the `delete` operator itself (the two-step process of destruction and deallocation) cannot be overloaded, the underlying deallocation function (`operator delete`) can be overloaded either globally or at the class scope to implement custom memory management strategies. ```cpp theme={"dark"} // Global or class-specific overload signatures void operator delete(void* ptr) noexcept; void operator delete[](void* ptr) noexcept; // C++14 introduced sized deallocation overloads void operator delete(void* ptr, std::size_t sz) noexcept; void operator delete[](void* ptr, std::size_t sz) noexcept; ```
Tired of Poor C++ Skills? Fix That With Deep Grasping! Learn More