从一段网络编程代码读懂 C++ RAII:构造申请,析构释放
摘要
本文从一个真实的 Windows TCP 服务器程序出发,经历"手动清理 → goto → do...while(0) → RAII "四个版本的演进,讲清楚 C++ 中最重要的编程惯用法之一:RAII(Resource Acquisition Is Initialization)。文中示例可直接编译运行,并配有异常场景下的对比实验,帮助读者真正理解"为什么要把资源交给对象管"。
1. 问题的起点:一段充满重复清理逻辑的代码
1.1 问题背景
初学服务器开发时,一个经典练习是:写一个 TCP 服务器,客户端连上来后发一条 "HelloWorld" 然后断开。在 Windows 上,流程是:
初始化网络库 WSAStartup → 创建 socket → bind → listen → 循环 accept 并发送消息 → 程序结束时 closesocket 并 WSACleanup。
最初的写法(版本一)在每个可能失败的步骤里,都重复写了一遍清理代码:
暂时不了解网络编程的小伙伴可以先跳过理解这段代码的逻辑部分,下面会围绕RAII抽象出问题实质
#include <winsock2.h>
#include <stdio.h>
//链接Windows的socket库
#pragma comment(lib, "ws2_32.lib")
int main(int argc, char* argv[])
{
//初始化socket库
WORD wVersionRequested = MAKEWORD(1, 1);
WSADATA wsaData;
int err = WSAStartup(wVersionRequested, &wsaData);
if (err != 0)
return 1;
if (LOBYTE(wsaData.wVersion) != 1 || HIBYTE(wsaData.wVersion) != 1)
{
WSACleanup();
return 1;
}
//创建用于监听的套接字
SOCKET sockSrv = socket(AF_INET, SOCK_STREAM, 0);
if (sockSrv == -1)
{
WSACleanup();
return 1;
}
SOCKADDR_IN addrSrv;
addrSrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
addrSrv.sin_family = AF_INET;
addrSrv.sin_port = htons(6000);
//绑定套接字,监听6000端口
if (bind(sockSrv, (SOCKADDR*)&addrSrv, sizeof(SOCKADDR)) == -1)
{
closesocket(sockSrv);
WSACleanup();
return 1;
}
//启动监听,准备接受客户请求
if (listen(sockSrv, 15) == -1)
{
closesocket(sockSrv);
WSACleanup();
return 1;
}
SOCKADDR_IN addrClient;
int len = sizeof(SOCKADDR);
char msg[] = "HelloWorld";
while (true)
{
//等待客户请求到来,如果有客户端连接,则接受连接
SOCKET sockClient = accept(sockSrv, (SOCKADDR*)&addrClient, &len);
if (sockClient == -1)
break;
//给客户端发送”HelloWorld“消息
send(sockClient, msg, strlen(msg), 0);
closesocket(sockClient);
}// end while-loop
closesocket(sockSrv);
WSACleanup();
return 0;
}
1.2 抽象问题
把网络代码换成更简单的堆内存例子,痛点一目了然:
// 伪代码
char* p = new char[1024]; // 申请资源
if (操作1失败) { delete[] p; return; } // 出错,手动释放
if (操作2失败) { delete[] p; return; } // 出错,手动释放
if (操作3失败) { delete[] p; return; } // 出错,手动释放
delete[] p; // 正常结束,手动释放
这里 delete[] p 出现了 4 次。只要漏写任何一次,就发生内存泄漏。代码越复杂、出口越多,越容易漏。这就是本文要解决的核心问题。
2. 三种"土办法"及其缺陷
2.1 版本二:goto 统一清理点
把所有清理代码集中到函数末尾的标签处,出错就 goto 过去。
// 伪代码
SOCKET sockSrv = socket(...);
if (sockSrv == -1) goto cleanup2;
if (bind(...) == -1) goto cleanup1;
// ...
cleanup1:
closesocket(sockSrv);
cleanup2:
WSACleanup();
优点:清理逻辑只写一遍。
缺点:goto 让程序结构混乱、难维护;且 goto 不能跳过变量定义,变量须提前声明。
2.2 版本三:do...while(0) + break
用假循环包住主体,出错用 break 跳出,循环外统一清理:
// 伪代码
char* p = NULL;
do {
p = new char[1024];
if (操作1失败) break;
if (操作2失败) break;
if (操作3失败) break;
} while (0);
delete[] p; // 统一清理
p = NULL;
优点:比 goto 干净。
缺点:仍是"手动清理",只是把清理点集中了;写法绕;最关键的——它处理不了异常(见第 5 节的对比实验)。
核心要点
版本二、三的共同局限:它们只能处理"正常流程中的提前返回"。一旦某行代码抛出异常,控制流会直接飞出整个结构,末尾的清理代码根本执行不到。
3. RAII:换个根本思路
3.1 核心思想
前面三个版本都在"手动清理"上做文章。RAII 换了个思路:
RAII 一句话定义:把资源包装成一个 C++ 对象——资源在构造函数里申请,在析构函数里释放。因为 C++ 保证对象离开作用域时析构函数一定被调用,不管是正常 return、提前 return,还是抛了异常。
下面提供了两种理解方式。
3.2 用堆内存理解
把裸指针封装成类:
// 伪代码
class HeapObjectWrapper {
public:
HeapObjectWrapper(int size) {
m_p = new char[size]; // 构造时申请资源
}
~HeapObjectWrapper() {
delete[] m_p; // 析构时释放资源
m_p = NULL;
}
private:
char* m_p;
};
// 使用:
HeapObjectWrapper heapObj(1024); // 对象创建,资源已就绪
if (操作1失败) return; // 直接 return,heapObj 析构 → 自动 delete[]
if (操作2失败) return; // 直接 return,heapObj 析构 → 自动 delete[]
if (操作3失败) return; // 直接 return,heapObj 析构 → 自动 delete[]
// 正常结束,heapObj 析构 → 自动 delete[]
delete[] 现在只出现在一个地方(析构函数),程序员再也不用在每个 return 前记得写清理代码。
3.3 用锁理解
传统写法每个 return 前都要解锁,漏一个就死锁:
// 伪代码
void SomeFunction() {
加锁;
if (条件1) {
if (条件2) { 操作; 解锁; return; }
else { 操作; 解锁; return; }
}
if (条件3) { 操作; 解锁; return; }
操作4; 解锁;
}
RAII 写法:
// 伪代码
class SomeLockGuard {
public:
SomeLockGuard() { m_lock.lock(); } // 构造时加锁
~SomeLockGuard() { m_lock.unlock(); } // 析构时解锁
private:
SomeLock m_lock;
};
void SomeFunction() {
SomeLockGuard lockWrapper; // 构造 → 加锁
if (条件1) { ... return; } // 直接 return,析构 → 自动解锁
if (条件3) { ... return; } // 直接 return,析构 → 自动解锁
操作4; // 函数结束,析构 → 自动解锁
}
一个"解锁"都不用写,却永远不会漏。这正是 C++11 std::lock_guard 的原理。
4. 回到网络编程:版本四
用 RAII 改写 TCP 服务器,核心是一个 ServerSocket 类,把清理统一放进析构函数:
// 伪代码
class ServerSocket {
public:
ServerSocket() { m_bInit = false; m_ListenSocket = -1; }
~ServerSocket() { // 析构:自动清理
if (m_ListenSocket != -1) ::closesocket(m_ListenSocket);
if (m_bInit) ::WSACleanup();
}
bool DoInit() { /* 初始化网络库、创建 socket */ }
bool DoBind(...) { ... }
bool DoListen(...) { ... }
bool DoAccept() { ... }
private:
bool m_bInit;
SOCKET m_ListenSocket;
};
int main() {
ServerSocket serverSocket; // 创建对象
if (!serverSocket.DoInit()) return 1;
if (!serverSocket.DoBind(...)) return 1;
if (!serverSocket.DoListen(15)) return 1;
if (!serverSocket.DoAccept()) return 1;
return 0;
}
main 里没有任何一处手动清理。中间任何一个 if 失败 return,serverSocket 都会析构、自动完成 closesocket 与 WSACleanup。
注意
没有把资源申请放进构造函数,而是单独写了 DoInit() 返回 bool。原因是初始化可能失败,而构造函数不方便返回失败信息。这是工程中的折中,但清理统一放析构的核心不变。
5. 动手实验:异常场景下 RAII 的价值
5.1 完整异常实验代码
首先看这段完整的代码示例,可以动手尝试一下
#include <iostream>
#include <stdexcept> // std::runtime_error
using namespace std;
class HeapObjectWrapper {
public:
HeapObjectWrapper(int size) {
m_p = new char[size];
cout << "构造函数:申请了 " << size << " 字节内存\n";
}
~HeapObjectWrapper() {
delete[] m_p;
cout << "析构函数:内存已释放\n";
}
private:
char* m_p;
};
bool step1() { cout << "执行步骤1\n"; return true; }
bool step2() {
cout << "执行步骤2,准备抛异常\n";
throw runtime_error("boom"); // 抛出异常
}
int main() {
try {
HeapObjectWrapper obj(1024);
if (!step1()) return 1;
if (!step2()) return 1; // step2 抛异常,走不到 return
cout << "全部成功\n"; // 不执行
}
catch (const runtime_error& e) {
cout << "捕获到异常:" << e.what() << "\n";
}
cout << "程序继续执行到这里\n";
return 0;
}
输出结果:

注意:析构发生在"捕获到异常"之前。throw 一发生,try 块立刻展开,其中所有局部对象先析构,再跳到 catch。这就是 RAII 在异常下也能释放资源的根本原因。
5.2 对比实验:裸指针版会泄漏
把对象换成裸指针,其余不变:
// 伪代码
int main() {
try {
char* p = new char[1024];
cout << "申请了内存\n";
if (!step2()) { /* ... */ } // step2 抛异常
delete[] p; // 永远执行不到!
}
catch (const runtime_error& e) {
cout << "捕获到异常:" << e.what() << "\n";
}
return 0;
}
运行后"内存已释放"完全消失——delete[] p 在异常时被跳过,1024 字节泄漏。而 RAII 版同样抛异常,析构照常执行、内存照常释放。这就是本文的核心结论。
6. 总结
| 版本 | 做法 | 清理方式 | 主要缺点 |
|---|---|---|---|
| 版本一 | 每个出错分支手动清理 | 手动 | 重复、易漏 |
| 版本二 | goto 统一清理点 手动 | 结构混乱,不处理异常 | |
| 版本三 | do...while(0) + break | 手动 | 写法绕,不处理异常 |
| 版本四 | 资源包装成对象 | 析构自动 | 需理解对象生命周期 |
核心要点
RAII:资源交给对象管,构造申请、析构释放,离开作用域自动清理,正常返回、提前返回、抛异常都管用。现实中的std::lock_guard、std::unique_ptr、std::shared_ptr全是这个思想的产物。
资源泄漏与死锁问题隐蔽性强、生产环境难复现难排查。理解并熟练使用 RAII,不仅让代码更简洁模块化,更能在开发阶段就避免大量资源泄漏与死锁问题。
参考资料:
浙公网安备 33010602011771号