16、C语言中的对象生命周期管理：构造函数与析构函数模拟、资源获取即初始化

说到C语言的内存管理，有个话题我一直觉得特别有意思——对象的生命周期管理。

你可能用过C++，知道它有构造函数和析构函数。对象一创建，构造函数自动跑；对象一销毁，析构函数自动收尾。干净利落。

但C语言没有这些。怎么办？

嗯，我早年做嵌入式项目时也纠结过这个问题。后来发现，用纯C模拟出构造和析构的行为，不仅可行，而且能让代码质量上一个台阶。今天我们就来聊聊这个。

为什么需要生命周期管理？

先看一个常见场景。你写了一个模块，里面有个结构体，包含一个动态分配的缓冲区：

typedef struct {
    int id;
    char *buffer;
    size_t size;
} DataObject;

这个结构体用起来很简单：

DataObject obj;
obj.id = 1;
obj.buffer = malloc(1024);
obj.size = 1024;

但问题来了——谁负责释放buffer？

如果使用者忘了free，内存泄漏。如果使用者重复free，程序崩溃。我在项目中见过太多次这种bug了。

说白了，C语言没有强制性的生命周期管理，全靠程序员自觉。但自觉是靠不住的。我们需要一套约定和机制，让对象的创建和销毁变得可控。

模拟构造函数：初始化函数

构造函数的核心作用是什么？确保对象在创建时就处于一个合法、可用的状态。

在C语言中，我们用一个专门的初始化函数来模拟：

// 构造函数模拟
int DataObject_init(DataObject *obj, int id, size_t size) {
    if (obj == NULL || size == 0) {
        return -1;  // 参数校验
    }

    obj->buffer = malloc(size);
    if (obj->buffer == NULL) {
        return -1;  // 内存分配失败
    }

    obj->id = id;
    obj->size = size;
    memset(obj->buffer, 0, size);  // 初始化为0

    return 0;  // 成功
}

使用方式：

DataObject obj;
if (DataObject_init(&obj, 42, 1024) != 0) {
    // 处理错误
}

我个人习惯把这种函数命名为 xxx_init 或 xxx_create。前者用于栈上对象，后者用于堆上对象。

小技巧：初始化函数一定要做参数校验。我曾经在一个项目中漏掉了NULL检查，结果线上设备跑了三天后突然崩溃——就是因为某个路径传入了空指针。从那以后，我的初始化函数第一行永远是参数检查。

模拟析构函数：清理函数

析构函数的任务正好相反——释放对象占用的所有资源，然后让对象进入“已销毁”状态。

// 析构函数模拟
void DataObject_destroy(DataObject *obj) {
    if (obj == NULL) {
        return;
    }

    // 释放内部资源
    if (obj->buffer != NULL) {
        free(obj->buffer);
        obj->buffer = NULL;  // 防止悬空指针
    }

    // 标记对象为已销毁
    obj->id = -1;
    obj->size = 0;
}

使用方式：

DataObject_destroy(&obj);

注意这里有个关键点：释放后将指针置为NULL。你想想看，如果有人不小心在destroy之后又调用了destroy，第二次调用时free(NULL)是安全的。这就是所谓的“幂等性”——多次调用不会产生副作用。

重要：千万不要在析构函数里free对象本身（除非对象是在堆上分配的）。如果对象在栈上，free栈地址会导致未定义行为。我见过有人把栈对象和堆对象的析构写成一个函数，结果出了大问题。

资源获取即初始化（RAII）的C语言实现

RAII是C++中的一个核心思想：资源的生命周期与对象的生命周期绑定。对象创建时获取资源，对象销毁时释放资源。

C语言没有自动的构造和析构，但我们可以手动实现这个模式。核心思路是：在初始化函数中分配所有资源，在析构函数中释放所有资源。

来看一个更完整的例子——一个简单的文件读取器：

typedef struct {
    FILE *fp;
    char *path;
    int is_open;
} FileReader;

// 构造函数：打开文件
int FileReader_init(FileReader *reader, const char *path) {
    if (reader == NULL || path == NULL) {
        return -1;
    }

    reader->fp = fopen(path, "r");
    if (reader->fp == NULL) {
        return -1;
    }

    reader->path = strdup(path);
    if (reader->path == NULL) {
        fclose(reader->fp);
        return -1;
    }

    reader->is_open = 1;
    return 0;
}

// 析构函数：关闭文件
void FileReader_destroy(FileReader *reader) {
    if (reader == NULL) {
        return;
    }

    if (reader->is_open && reader->fp != NULL) {
        fclose(reader->fp);
        reader->fp = NULL;
    }

    if (reader->path != NULL) {
        free(reader->path);
        reader->path = NULL;
    }

    reader->is_open = 0;
}

使用模式：

FileReader reader;
if (FileReader_init(&reader, "data.txt") == 0) {
    // 使用reader...
    // 不用担心资源泄漏
    FileReader_destroy(&reader);
}

这个模式的好处是：资源获取和释放成对出现，不会遗漏。你只要记住“init之后必须destroy”，就不会有资源泄漏。

生命周期管理的核心原则

根据我多年的经验，总结出几条铁律：

  1. 谁分配，谁释放——初始化函数分配的资源，必须由对应的析构函数释放。
  2. 初始化函数必须完整——要么全部资源都分配成功，要么一个都不分配（回滚）。
  3. 析构函数必须幂等——多次调用不会产生错误。
  4. 对象使用前必须初始化——未初始化的对象不能使用。
核心思想：把资源管理的复杂性封装在init/destroy函数内部，使用者只需要关心“创建-使用-销毁”这个简单流程。

一个完整的实战案例

下面是一个网络连接管理器的例子，展示了完整的生命周期管理：

typedef struct {
    int sockfd;
    char *host;
    int port;
    int connected;
} Connection;

// 构造函数
int Connection_init(Connection *conn, const char *host, int port) {
    if (conn == NULL || host == NULL || port <= 0) {
        return -1;
    }

    conn->sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (conn->sockfd < 0) {
        return -1;
    }

    conn->host = strdup(host);
    if (conn->host == NULL) {
        close(conn->sockfd);
        return -1;
    }

    conn->port = port;
    conn->connected = 0;
    return 0;
}

// 析构函数
void Connection_destroy(Connection *conn) {
    if (conn == NULL) {
        return;
    }

    if (conn->connected) {
        // 先断开连接
        shutdown(conn->sockfd, SHUT_RDWR);
    }

    if (conn->sockfd >= 0) {
        close(conn->sockfd);
        conn->sockfd = -1;
    }

    if (conn->host != NULL) {
        free(conn->host);
        conn->host = NULL;
    }

    conn->connected = 0;
    conn->port = 0;
}

使用方式：

Connection conn;
if (Connection_init(&conn, "example.com", 80) == 0) {
    // 连接成功，可以正常使用
    // ...
    // 使用完毕后销毁
    Connection_destroy(&conn);
}

知识体系总览

下面这张图总结了C语言中对象生命周期管理的核心逻辑：

C语言对象生命周期管理 1. 构造函数模拟 xxx_init() / xxx_create() 2. 使用阶段 正常操作对象 3. 析构函数模拟 xxx_destroy() / xxx_free() 核心原则：谁分配谁释放 | 初始化必须完整 | 析构必须幂等 | 使用前必须初始化 RAII 模式在C语言中的实现 • 构造函数中：malloc / fopen / socket → 获取所有资源 • 析构函数中：free / fclose / close → 释放所有资源 • 使用者只需：init → 使用 → destroy，无需关心内部细节

避坑指南

最后，分享几个我踩过的坑：

  • 不要忘记初始化——我曾经在代码里直接使用了一个栈上的结构体，没有调用init，结果里面的指针是野指针，一用就崩。后来我养成了习惯：所有对象在使用前必须调用init。
  • 不要在析构函数里做太多事情——析构函数应该只做资源释放。如果你在里面写日志、发通知、回调其他模块，很容易出问题。我见过一个析构函数里调用了另一个对象的destroy，结果形成了循环调用，栈溢出了。
  • 考虑线程安全——如果你的对象可能被多个线程访问，init和destroy需要加锁。但要注意，destroy里释放锁要小心，别在释放资源后还去操作锁。

好了，关于C语言中的对象生命周期管理，就聊到这里。记住一句话：好的代码，资源管理是成对出现的。init和destroy就像一对括号，永远不分开。

公众号:蓝海资料掘金营，微信deep3321

← 上一章 📖 返回目录 下一章 →