C++ Memory Allocation: new and delete

In C++ programming, mastering dynamic memory management is a critical capability for developing high-performance, resource-efficient programs. Unlike static arrays, the new and delete operators allow developers to flexibly allocate and release storage space in the heap based on runtime requirements. A correct understanding and application of these two operators not only prevent common memory leak issues but also effectively avoid undefined behaviors caused by dangling pointers.
When dynamic acquisition of continuous or scattered memory spaces is required during program execution, the new operator should be preferred over traditional C language malloc functions. The new operator handles not only the allocation of raw byte count (i.e., sizeof) but also automatically invokes the object's constructor to initialize member variables. This characteristic ensures that newly created instances are in a "ready" state and can be used directly immediately after creation.

The basic syntax is as follows:

int* ptr = new int; // Allocates space for an integer variable and initializes it by default to 0
std::string str = "Hello"; 
// Equivalent to the following process:
// std::string *sPtr = new std::string();
// sPtr->assign("Hello");

For basic data types, new behaves similarly to malloc plus initialization; however, for class type objects (such as the string above), it automatically executes construction logic. For example, creating an integer array containing 10 elements:

int* arr = new int[10]; // Allocates continuous space and invokes the constructor for each element
// The memory pointed to by 'arr' is now safe to write data into
for (int i = 0; i < 10; ++i) {
    arr[i] = i * 2;
}

Functionality of delete Operator and Precautions

The delete operator in C++ is specifically designed for releasing dynamically allocated memory. Its core responsibilities are twofold: first, it invokes the object's destructor to clean up internal resources; second, it returns heap space back to the operating system for subsequent program reuse. Failing to manually release memory after using malloc leads to severe memory leaks, causing programs to run slowly or even crash.

There is a significant difference in how single objects and arrays are deleted:

Single Element: delete ptr; invokes the destructor and releases space.
Multi-element Array: Must use delete[] ptr;; strictly forbidden to write delete ptr; (unless only one element was allocated).

Incorrect usage leads to undefined behavior because the compiler cannot determine whether a loop-invoked destruction logic is required:

// Correct Usage
int* arr = new int[10];
delete [] arr; 

// Dangerous Writing Style (even if 'arr' has only one element)
int *single = new int(42); 
// delete single; // Error! Should use delete single; (singular form)

// If mistakenly using delete[] on a single object:
std::string s = "test";
sPtr = new std::string("data");
delete [] sPtr; // Although it usually works, this is semantically incorrect and inefficient

RAII Pattern and Modern Alternatives

Although new/delete form the cornerstone of C++ memory management, in modern C++ development, it is recommended to prioritize using smart pointers (such as std::unique_ptr and std::shared_ptr) to encapsulate raw operations. These containers automatically manage lifetimes by invoking destructors to release resources at the end of their scope, thereby completely eliminating risks associated with manual deletion.

#include <memory>
// Exclusive ownership: Automatically deletes when object is destroyed
auto ptr = std::make_unique<int>(10); 
int* rawPtr = new int(5); // Raw method requires manual management

std::unique_ptr<int> uptr(rawPtr); // Takes control and releases memory of 'rawPtr'

By adhering to these principles, developers can build more robust and maintainable codebases. Whether in the early stages of learning or advanced development phases, deeply understanding the underlying mechanisms of new and delete is an important step toward mastering C++.