How to manage pointer lifetime in C++?

Smart pointers (such as unique_ptr, shared_ptr, weak_ptr) are the preferred method of managing the life cycle of C pointers, automatically releasing pointers and preventing memory leaks. When managing pointers manually, use delete and delete[] to free pointers to heap-allocated objects and dynamic arrays, and follow best practices such as prioritizing smart pointers, freeing pointers promptly, and avoiding circular references.

How to manage the life cycle of pointers in C

It is crucial to manage the life cycle of pointers in C to ensure that applications Program stability and prevention of memory leaks. This article will introduce different methods of pointer life cycle management and illustrate them through practical cases.

Smart pointer

Smart pointer is a library class that automatically manages the life cycle of pointers. The following are several common smart pointers:

• unique_ptr: Exclusive ownership ensures that the pointer is released when the scope ends.
• shared_ptr: Shared ownership, uses a counting reference count to track the number of references to a pointer, and releases the pointer when the number of references reaches 0.
• weak_ptr: Weak reference will not increase the reference count and is used to prevent circular references.

Example: Using unique_ptr

#include <memory>

int main() {
  // 创建一个指向堆分配对象的 unique_ptr
  std::unique_ptr<int> ptr = std::make_unique<int>(42);

  // 访问对象
  *ptr = 100;

  // 指针超出作用域，对象被释放
}

Manual management

In some cases, smart pointers cannot be used . At this point, the pointer's lifetime must be managed manually. The following are common ways to free a pointer:

• delete: Releases a pointer to a heap-allocated object.
• delete[]: Release the pointer to the dynamic array.

Example: Manually managing pointers

int* ptr = new int[10];

// 使用指针
ptr[0] = 1;

// 释放指针
delete[] ptr;

Best Practices

• Prefer smart pointers.
• If you must manage pointers manually, release them as soon as they are no longer needed.
• Use pointer management tools, such as Valgrind, to detect memory leaks.
• Avoid circular references, which may cause memory leaks.

The above is the detailed content of How to manage pointer lifetime in C++?. For more information, please follow other related articles on the PHP Chinese website!