How Can I Avoid Memory Leaks When Using `new` in C ?

Memory Leaks and the Misuse of 'new' in C

Unlike its C# counterpart, operator 'new' in C allocates memory dynamically, creating objects with extended lifespans. This poses a potential challenge in memory management.

Memory Leaks Explained

When using 'new' to allocate memory, the allocated object resides in the heap, a region of memory outside the stack used for automatic variable storage. Since this object outlives its scope, it must be manually released using 'delete' to prevent a memory leak.

The code snippet you provided demonstrates this:

A *object1 = new A();
B object2 = *(new B());

• object1 is a pointer to an object allocated with 'new'. If not deleted, it will result in a memory leak.
• object2 copies from another object created with 'new'. This loses the original pointer, making delete inaccessible and thus causing a memory leak.

Proper Memory Management

To avoid memory leaks, follow these guidelines:

• Prefer Automatic Storage Duration: For objects with limited lifespan, declare them with T object; instead of 'new'. These objects are automatically cleaned up once out of scope.
• Use Smart Pointers: For objects with dynamic storage duration, use smart pointers like std::unique_ptr or std::shared_ptr. These pointers manage the memory and automatically deallocate objects when no longer referenced.

Example with Smart Pointers:

std::unique_ptr<A> object1 = std::make_unique<A>();
std::shared_ptr<B> object2 = std::make_shared<B>();

With smart pointers, the objects will be deleted automatically when they are no longer needed, ensuring proper memory management.

The above is the detailed content of How Can I Avoid Memory Leaks When Using `new` in C ?. For more information, please follow other related articles on the PHP Chinese website!