C++ smart pointers: Make pointers smarter and get rid of the troubles of memory management

Smart pointer: a special pointer in C that encapsulates the original pointer and provides additional functions. Type: std::unique_ptr: unique ownership, memory is released after the pointer expires. std::shared_ptr: shared ownership, memory is released when the last reference disappears. std::weak_ptr: Weak ownership, does not prevent the object from being destroyed, and avoids circular references. Usage: Declare a smart pointer type to replace ordinary pointers. Practical case: Use std::shared_ptr to manage the file stream and automatically close the file stream regardless of whether an exception occurs.

C Smart pointers: Make pointers smarter and get rid of the troubles of memory management

In modern C, smart pointers are an improvement Powerful tools for application robustness and memory management efficiency, they automate memory management tasks, freeing developers from potential bugs and memory leaks.

What is a smart pointer?

Smart pointers are special pointers in C that encapsulate raw pointers and provide additional functionality, including automatic memory release, exception safety, and reference count management.

Types of smart pointers

There are three commonly used smart pointer types in C:

• std::unique_ptr:The unique ownership pointer to a single object. The pointer becomes invalid after ownership is released.
• std::shared_ptr: The shared ownership pointer to the object. The object is released when the last reference disappears.
• std::weak_ptr: Weak ownership pointer to the object. Does not prevent the object from being destroyed and is used to avoid circular references.

Usage method

Using smart pointers is very simple, just declare the smart pointer type as a replacement for ordinary pointers, as follows:

// 使用 unique_ptr 管理一个 int
std::unique_ptr<int> number(new int(10));

// 使用 shared_ptr 管理一个 string
std::shared_ptr<std::string> text(new std::string("Hello world!"));

Practical case

Consider the following scenario, in which we want to read the file content from the file through the file reading function:

std::string readFile(const std::string& fileName) {
  std::ifstream file(fileName);

  // 检查文件是否打开
  if (!file.is_open()) {
    throw std::runtime_error("无法打开文件！");
  }

  // 读取文件内容到字符串中
  std::string content;
  file >> content;

  // 关闭文件
  file.close();

  // 返回文件内容
  return content;
}

This code exists Two main problems:

1. If opening the file fails, the exception is not handled correctly, which can lead to unexpected behavior.
2. The file.close() call responsible for closing the file needs to be executed under any circumstances, even if an exception occurs.

Using smart pointers, we can easily solve these problems:

std::string readFile(const std::string& fileName) {
  // 使用 shared_ptr 管理文件流
  std::shared_ptr<std::ifstream> file(new std::ifstream(fileName));

  // 检查文件是否打开
  if (!*file) {
    throw std::runtime_error("无法打开文件！");
  }

  // 读取文件内容到字符串中
  std::string content;
  *file >> content;

  // 文件流将由 shared_ptr 自动关闭
  return content;
}

By using std::shared_ptr, the file stream will be automatically closed regardless of whether it occurs abnormal. Additionally, the code now safely handles failure to open the file and communicates this to the caller via an exception.

The above is the detailed content of C++ smart pointers: Make pointers smarter and get rid of the troubles of memory management. For more information, please follow other related articles on the PHP Chinese website!