C语言中如何区分内存大小相同的int/float、double/char*类型？

你的核心问题是仅靠sizeof无法区分内存占用相同的类型（比如int/float、double/char*），之前的字符串判断方法存在严重误判风险，下面给出几个可靠的解决方案：

一、最稳妥的方案：给集合结构体添加类型标识 #

直接在集合结构体里记录元素的明确类型，彻底避免"猜类型"的问题，这是工业级代码的常规做法：

1. 定义类型枚举与集合结构体 #

#include <stddef.h>
#include <limits.h>

// 枚举所有需要支持的元素类型
typedef enum {
    TYPE_INT,
    TYPE_FLOAT,
    TYPE_DOUBLE,
    TYPE_STRING, // 对应char*类型
    // 可扩展其他类型
} ElementType;

// 修改集合结构体，增加类型标识字段
typedef struct {
    void* elements;       // 存储元素的内存块
    size_t element_size;  // 单个元素的大小
    ElementType elem_type;// 明确记录元素类型
    size_t count;         // 当前元素数量
    size_t capacity;      // 内存块容量
} Set;

2. 初始化与添加元素的逻辑 #

初始化集合时直接指定类型，后续添加元素时只需对比类型即可：

// 初始化集合示例
void init_set(Set* set, ElementType type, size_t elem_size) {
    set->elements = NULL;
    set->element_size = elem_size;
    set->elem_type = type;
    set->count = 0;
    set->capacity = 0;
}

// 添加元素时的类型检查示例
int add_to_set(Set* set, ElementType elem_type, const void* elem) {
    if (set->count == 0) {
        // 第一个元素，直接存入
        set->elem_type = elem_type;
    } else if (elem_type != set->elem_type) {
        printf("元素类型不匹配，集合当前仅接受指定类型元素\n");
        return -1;
    }
    // 后续添加元素的逻辑...
    return 0;
}

这种方法完全消除了类型歧义，代码可读性和维护性远高于"猜类型"的方案。

二、利用类型的内存布局特性区分（仅当无法添加类型标识时使用） #

如果因限制不能修改集合结构体，可以利用不同类型的二进制格式特性区分，但这种方法依赖平台（比如IEEE754浮点格式、指针地址规则），兼容性稍差：

1. 区分int与float（仅当sizeof(int) == sizeof(float)时） #

利用IEEE754单精度浮点数的二进制结构：只有尾数位全为0时，浮点数才表示整数，结合数值范围判断：

#include <stdint.h>

int is_int(const void* data) {
    union {
        int32_t i;
        float f;
    } u;
    u.i = *(const int32_t*)data;
    
    // 解析IEEE754单精度浮点数的各部分
    uint32_t bits = *(const uint32_t*)data;
    uint32_t mantissa = bits & 0x7FFFFF; // 尾数位（23位）
    
    // 尾数位全0，且数值在int范围内，说明是int类型
    if (mantissa == 0) {
        float f_val = u.f;
        if (f_val >= INT_MIN && f_val <= INT_MAX && (int32_t)f_val == u.i) {
            return 1;
        }
    }
    return 0; // 是float类型
}

2. 区分double与char*（仅当sizeof(double) == sizeof(char*)时） #

64位系统中，double和char*都是8字节，但用户空间指针有固定地址范围，结合字符串以'\0'结尾的特性判断（注意：非法指针访问可能触发段错误）：

#include <stdint.h>
#include <string.h>

int is_string_ptr(const void* data) {
    uint64_t ptr_val = *(const uint64_t*)data;
    // 64位Linux用户空间地址通常不超过0x00007FFFFFFFFFFF
    if (ptr_val > 0x00007FFFFFFFFFFF) {
        return 0; // 不是合法指针，是double
    }
    
    char* str = (char*)ptr_val;
    // 检查是否是以'\0'结尾的字符串
    for (int i = 0; i < 256; i++) {
        if (str[i] == '\0') {
            return 1; // 是字符串指针
        }
    }
    return 0; // 不是字符串，是double
}

注意：这种方法有局限性，比如double数值恰好落在合法指针范围且指向内存有'\0'时会误判，仅作为临时方案。

三、现有代码的问题说明 #

• int/float字符串判断：snprintf会把int转成带.000000000后缀的字符串，导致误判为float；float值为整数时（如2.0f）也会被误判为int。
• double/char*判断：strchr(set->elements, '\0')检查的是集合内存块本身，double二进制可能含'\0'字节导致误判；把double当成char*调用strcmp会触发未定义行为，可能崩溃。

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