进程终止时为何需要执行清理操作？

Great question—this is one of those common pitfalls that catches many C++ developers early on. While it’s true that modern operating systems will reclaim all memory allocated by a process when it terminates, relying solely on that is a bad practice for several critical reasons:

• Resources aren’t just RAM
  Your process might hold onto non-memory resources that the OS either won’t reclaim immediately, or will reclaim but only after causing problems during runtime. Think about file handles, network sockets, database connections, mutex locks, or even hardware device handles. For example:

  • If you open a file with FILE* f = fopen("data.txt", "w"); and never call fclose(f);, the OS will eventually close it when the process dies—but if your program loops this operation hundreds of times, you’ll hit the system’s limit for open file handles long before the process ends, causing subsequent fopen calls to fail.
  • A locked mutex that’s never unlocked could leave other threads (or even other processes waiting on the same resource) stuck indefinitely, even if your process exits.

• RAII and code reusability
  C++ is built around the RAII (Resource Acquisition Is Initialization) principle. If you skip manual cleanup (or more accurately, let RAII handle it via destructors), your code becomes fragile and hard to reuse. Suppose you write a class that allocates dynamic memory in its constructor but doesn’t free it in the destructor. If you create an instance of this class inside a function that returns early or throws an exception, that memory leaks while the process is still running. Worse, if later you port this code to a long-running process (like a server), those leaks will accumulate over time, eventually causing the process to run out of memory and crash.

• Debugging and maintainability
  Ignoring cleanup makes it impossible to tell accidental leaks from intentional ones. Tools like Valgrind or AddressSanitizer will flag all unfreed memory as leaks, forcing you to sift through false positives to find real bugs. This becomes a nightmare in large codebases—other developers might assume those "harmless" leaks are normal, letting actual problematic leaks slip through the cracks.

• Exception safety
  C++ programs often use exceptions to handle errors. If you allocate memory with new but don’t use a smart pointer (like std::unique_ptr) or wrap it in a RAII container, an exception thrown between allocation and deallocation will leave that memory unreachable until the process exits. For example:

  void risky_function() {
      int* buffer = new int[1024];
      some_function_that_throws(); // If this throws, buffer is never deleted
      delete[] buffer;
  }
  

  While the OS will clean up buffer when the process dies, if risky_function is called repeatedly, your program’s memory usage will grow steadily until it’s killed by the OS.

In short, the OS’s memory reclamation is a safety net, not a substitute for proper resource management. Following RAII and ensuring resources are cleaned up when they’re no longer needed keeps your code robust, efficient, and maintainable—whether it’s a short-lived command-line tool or a long-running service.

内容的提问来源于stack exchange，提问作者zonzor18