C语言中如何判断结构体指针成员是否可用？

问题背景 #

先看一个基础结构体示例：

typedef struct {
    char *like;
    int age;
    int class;
} info_t;

typedef struct {
    info_t *tom;
    info_t *jack;
} student;

如果未分配内存就直接访问结构体成员，会触发段错误：

student *s1;

s1->tom->like = "play game";

虽然可以尝试用空指针判断规避：

if(s1) {
    if(s1->tom) {
        s1->tom->like = "play game";
    }
}

但这种方式并不总是有效——未手动置为NULL的指针可能成为野指针，指向任意内存地址，无法通过空指针检查识别。

当前网络库的结构体与内存管理代码 #

我正在开发的网络库中，结构体和内存管理代码如下：

typedef struct {
    SOCKADDR *client;
    SOCKADDR *receiver;
    snSize size;
} snNetInfo_t;

typedef struct {
    snNetSocket sockfd;       // 大小：Windows[8], Linux[4]
    sn_u32      sockfdFamily; // 大小：4
    snNetType   sockfdType;   // 大小：Windows[4], Linux[8]
    snNetInfo_t *info;        // 大小：8
} snNet_ctx;

SN_PUBLIC(snError) snNet_malloc_init SN_OPEN_API SN_FUNC_OF(
    (snNet_ctx **ctx, sn_u32 family)
) {
    if(!((*ctx) = (snNet_ctx *)malloc(sizeof(snNet_ctx)))) {
        // 申请snNet对象内存失败
        return snErr_Memory;
    }
    if(!((*ctx)->info  = (snNetInfo_t *)malloc(sizeof(snNetInfo_t)))) {
        // 申请snNet对象的info成员内存失败
        return snErr_Memory;
    }
    if(family == AF_INET) {
        (*ctx)->sockfdFamily = AF_INET;
        (*ctx)->info->size = SN_NET_IPV4_ADDR_SIZE;
    } else if(family == AF_INET6) {
        (*ctx)->sockfdFamily = AF_INET6;
        (*ctx)->info->size = SN_NET_IPV6_ADDR_SIZE;
    } else {
        // 既不是IPv4也不是IPv6
        return snErr_NetFamily;
    }
    (*ctx)->info->receiver = (SOCKADDR *)malloc((*ctx)->info->size);
    (*ctx)->info->client = (SOCKADDR *)malloc((*ctx)->info->size);
    if(!(*ctx)->info->receiver || !(*ctx)->info->client) {
        // 申请接收端或客户端信息内存失败
        return snErr_Memory;
    }
    return snErr_OK;
}

SN_PUBLIC(snError) snNet_release SN_OPEN_API SN_FUNC_OF(
    (snNet_ctx **ctx)
) {
    if((*ctx)) {
        if((*ctx)->info) {
            if((*ctx)->info->receiver)
                free((*ctx)->info->receiver);
            if((*ctx)->info->client)
                free((*ctx)->info->client);
            free((*ctx)->info);
        }
        free((*ctx));
        (*ctx) = snNull;
    }
    return snErr_OK;
}

由于库未来可能开源，若用户未提前调用snNet_malloc_init申请内存就执行snNet_release，可能引发意外问题，需要找到有效判断结构体指针成员是否可用的方法。

可行解决方案 #

1. 使用不透明指针，强制通过库函数创建对象 #

将结构体的具体定义放在库的内部头文件（不对外暴露），仅在公开头文件中声明结构体类型：

// 公开头文件 sn_net.h
typedef struct snNet_ctx snNet_ctx;
typedef struct snNetInfo_t snNetInfo_t;

这样用户无法直接声明snNet_ctx变量，必须通过snNet_malloc_init获取合法的对象指针，从根源上避免野指针问题。

2. 给结构体添加魔术数校验 #

在结构体中加入固定的魔术数字段，初始化时设置为特定值，释放时清零，判断对象合法性时校验该值：

修改结构体定义

#define SN_NET_CTX_MAGIC 0xDEADBEEF
#define SN_NET_INFO_MAGIC 0xCAFEBABE

typedef struct {
    sn_u32 magic; // info结构体校验魔术数
    SOCKADDR *client;
    SOCKADDR *receiver;
    snSize size;
} snNetInfo_t;

typedef struct {
    sn_u32 magic; // 主结构体校验魔术数
    snNetSocket sockfd;
    sn_u32      sockfdFamily;
    snNetType   sockfdType;
    snNetInfo_t *info;
} snNet_ctx;

初始化时设置魔术数

SN_PUBLIC(snError) snNet_malloc_init SN_OPEN_API SN_FUNC_OF(
    (snNet_ctx **ctx, sn_u32 family)
) {
    *ctx = snNull;
    snNet_ctx *new_ctx = (snNet_ctx *)malloc(sizeof(snNet_ctx));
    if(!new_ctx) {
        return snErr_Memory;
    }
    // 设置主结构体魔术数
    new_ctx->magic = SN_NET_CTX_MAGIC;

    snNetInfo_t *new_info = (snNetInfo_t *)malloc(sizeof(snNetInfo_t));
    if(!new_info) {
        free(new_ctx);
        return snErr_Memory;
    }
    // 设置info结构体魔术数
    new_info->magic = SN_NET_INFO_MAGIC;
    new_ctx->info = new_info;

    // 后续原有逻辑（地址族判断、内存分配）...

    *ctx = new_ctx;
    return snErr_OK;
}

释放时校验魔术数

SN_PUBLIC(snError) snNet_release SN_OPEN_API SN_FUNC_OF(
    (snNet_ctx **ctx)
) {
    if(!ctx || !(*ctx)) {
        return snErr_InvalidParam;
    }
    // 校验主结构体合法性
    if((*ctx)->magic != SN_NET_CTX_MAGIC) {
        return snErr_InvalidObject;
    }

    if((*ctx)->info) {
        // 校验info结构体合法性
        if((*ctx)->info->magic != SN_NET_INFO_MAGIC) {
            free(*ctx);
            *ctx = snNull;
            return snErr_InvalidObject;
        }
        // 释放子成员内存
        if((*ctx)->info->receiver) free((*ctx)->info->receiver);
        if((*ctx)->info->client) free((*ctx)->info->client);
        // 清零魔术数，避免重复释放
        (*ctx)->info->magic = 0;
        free((*ctx)->info);
    }
    // 清零主结构体魔术数
    (*ctx)->magic = 0;
    free(*ctx);
    *ctx = snNull;
    return snErr_OK;
}

野指针几乎不可能恰好命中预设的魔术数值，因此这种方式能有效区分合法对象和非法指针。

3. 修复初始化函数的内存泄漏问题 #

当前snNet_malloc_init存在内存泄漏：如果info的receiver或client分配失败，之前分配的ctx和info未被释放。修改后的初始化函数如下：

SN_PUBLIC(snError) snNet_malloc_init SN_OPEN_API SN_FUNC_OF(
    (snNet_ctx **ctx, sn_u32 family)
) {
    *ctx = snNull;
    snNet_ctx *new_ctx = (snNet_ctx *)malloc(sizeof(snNet_ctx));
    if(!new_ctx) {
        return snErr_Memory;
    }
    new_ctx->magic = SN_NET_CTX_MAGIC;

    snNetInfo_t *new_info = (snNetInfo_t *)malloc(sizeof(snNetInfo_t));
    if(!new_info) {
        free(new_ctx);
        return snErr_Memory;
    }
    new_info->magic = SN_NET_INFO_MAGIC;
    new_ctx->info = new_info;

    if(family == AF_INET) {
        new_ctx->sockfdFamily = AF_INET;
        new_info->size = SN_NET_IPV4_ADDR_SIZE;
    } else if(family == AF_INET6) {
        new_ctx->sockfdFamily = AF_INET6;
        new_info->size = SN_NET_IPV6_ADDR_SIZE;
    } else {
        free(new_info);
        free(new_ctx);
        return snErr_NetFamily;
    }

    new_info->receiver = (SOCKADDR *)malloc(new_info->size);
    new_info->client = (SOCKADDR *)malloc(new_info->size);
    if(!new_info->receiver || !new_info->client) {
        // 清理已分配的内存
        if(new_info->receiver) free(new_info->receiver);
        if(new_info->client) free(new_info->client);
        free(new_info);
        free(new_ctx);
        return snErr_Memory;
    }

    *ctx = new_ctx;
    return snErr_OK;
}

4. 提供栈对象初始化函数（可选） #

如果需要支持栈上分配的结构体，提供专门的初始化函数，确保成员被正确置空和初始化：

SN_PUBLIC(snError) snNet_stack_init(snNet_ctx *ctx, sn_u32 family) {
    if(!ctx) {
        return snErr_InvalidParam;
    }
    // 清零结构体，避免野指针
    memset(ctx, 0, sizeof(snNet_ctx));
    ctx->magic = SN_NET_CTX_MAGIC;

    snNetInfo_t *info = (snNetInfo_t *)malloc(sizeof(snNetInfo_t));
    if(!info) {
        return snErr_Memory;
    }
    memset(info, 0, sizeof(snNetInfo_t));
    info->magic = SN_NET_INFO_MAGIC;
    ctx->info = info;

    // 后续地址族判断、内存分配逻辑同snNet_malloc_init...
}

内容的提问来源于stack exchange，提问作者S-N