How Can I Avoid Memory Leaks When Using Dynamic Memory Allocation in C ?

Memory Leaks with Dynamic Memory Allocation in C

In C#, new operator allocates memory on the heap and initializes it with the default value for the data type. However, in C , the behavior of new operator differs significantly.

The code you provided demonstrates a memory leak:

class A { ... };
struct B { ... };

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

Here's why it occurs:

• A *object1 = new A() allocates memory in the heap and assigns the pointer to object1.
• B object2 = *(new B()) also allocates memory in the heap but assigns the value of the object to object2, not the pointer to the object. This results in a copy of the B object being created in the automatic storage duration (stack) while the original object remains in the heap.

To avoid memory leaks, follow these guidelines:

• Prefer automatic storage duration by using T t; instead of new T().
• For dynamic storage duration, store pointers to allocated objects in automatic storage duration objects that delete them automatically:

template<typename T>
class automatic_pointer {
public:
    automatic_pointer(T* pointer) : pointer(pointer) {}
    ~automatic_pointer() { delete pointer; }
    T& operator*() const { return *pointer; }
    T* operator->() const { return pointer; }
private:
    T* pointer;
};

int main() {
    automatic_pointer<A> a(new A());
    automatic_pointer<B> b(new B());
}

By using these techniques, you can prevent memory leaks and ensure proper resource management in C code.

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