• 博客园logo
  • 会员
  • 周边
  • 新闻
  • 博问
  • 闪存
  • 赞助商
  • Chat2DB
    • 搜索
      所有博客
    • 搜索
      当前博客
  • 写随笔 我的博客 短消息 简洁模式
    用户头像
    我的博客 我的园子 账号设置 会员中心 简洁模式 ... 退出登录
    注册 登录

利昂萧侯

  • 博客园
  • 联系
  • 订阅
  • 管理

公告

View Post

从一段网络编程代码读懂 C++ RAII:构造申请,析构释放

让资源管理不再靠"记得"。本文从一个真实的 Windows TCP 服务器程序出发,经历"手动清理 → goto → do...while(0) → RAII"四个版本的演进,讲清楚 C++ 中最重要的编程惯用法之一:**RAII(Resource Acquisition Is Initialization)**。文中示例可直接编译运行,并配有异常场景下的对比实验,帮助读者真正理解"为什么要把资源交给对象管"。

摘要

本文从一个真实的 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;
}

输出结果:
image
注意:析构发生在"捕获到异常"之前。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,不仅让代码更简洁模块化,更能在开发阶段就避免大量资源泄漏与死锁问题。

参考资料:

  • https://www.cppguide.cn/pages/essentialsofcppserverprogrammingch01-01/

posted on 2026-11-17 21:32  利昂萧侯  阅读(7)  评论(0)    收藏  举报

刷新页面返回顶部
 
博客园  ©  2004-2026
浙公网安备 33010602011771号 浙ICP备2021040463号-3