使用版本依赖数据文件的软件适配32位系统的最佳实践

通用设计思路 #

核心思路是差异点收敛+统一接口分发，把所有和32/64位相关的类型、逻辑差异全部收拢到独立的实现模块中，上层业务逻辑完全不感知底层位数差异，全程调用统一接口，仅在程序启动读取文件标记位时做一次分支判断，不会出现零散的if判断语句。

• 第一步：定义全量的位数相关操作抽象接口，覆盖所有涉及类型差异的读写、计算、转换操作
• 第二步：分别实现32位、64位两个版本的接口实例，所有差异逻辑仅在对应版本内部处理
• 第三步：启动读取文件标记后，仅做一次合法性校验和接口实例绑定，后续全流程复用绑定的实例

C 语言专属实现 #

C 语言可以通过函数指针表 + 通用联合类型实现上述逻辑：

公共头文件定义 #

#include <stdint.h>
#include <stdbool.h>

// 通用动态整数类型，上层无需感知内部存储
typedef union {
    uint32_t v32;
    uint64_t v64;
} DynInt;

// 位数相关操作的函数表，所有差异操作均在此声明
typedef struct {
    DynInt (*read_from_buf)(const uint8_t* buf);
    void (*write_to_buf)(uint8_t* buf, DynInt val);
    uint64_t (*to_uint64)(DynInt val);
    DynInt (*from_uint64)(uint64_t val);
    // 可按需扩展其他操作
} IntOps;

// 32/64位版本的操作表实现声明
extern const IntOps ops_32bit;
extern const IntOps ops_64bit;

// 全局操作指针，启动时仅赋值一次
extern const IntOps* g_int_ops;

32位版本实现示例 #

const IntOps ops_32bit = {
    .read_from_buf = [](const uint8_t* buf) {
        DynInt ret;
        ret.v32 = *(const uint32_t*)buf;
        return ret;
    },
    .write_to_buf = [](uint8_t* buf, DynInt val) {
        *(uint32_t*)buf = val.v32;
    },
    .to_uint64 = [](DynInt val) { return val.v32; },
    .from_uint64 = [](uint64_t val) {
        DynInt ret;
        ret.v32 = (uint32_t)val;
        return ret;
    }
};

64位版本实现逻辑和上述一致，仅将内部操作替换为v64字段即可。

初始化逻辑（启动时仅执行一次） #

bool init_int_ops(uint8_t file_bit_flag) {
    // 假设标记位1为32位生成的文件，2为64位生成的文件
    if (file_bit_flag == 1) {
        g_int_ops = &ops_32bit;
        return true;
    } else if (file_bit_flag == 2) {
        // 32位系统不支持64位生成的文件
#if UINTPTR_MAX == 0xffffffff
        return false;
#endif
        g_int_ops = &ops_64bit;
        return true;
    }
    return false;
}

上层业务逻辑全程通过g_int_ops操作DynInt类型即可，无需任何位数相关的分支判断。

C++ 语言专属实现 #

C++ 可以通过运行时多态或者静态分发实现，写法更简洁，类型安全性更高：

运行时多态实现 #

#include <memory>
#include <stdexcept>
#include <cstdint>

// 抽象接口基类
class BitIntHandler {
public:
    virtual ~BitIntHandler() = default;
    virtual uint64_t read(const uint8_t* buf) const = 0;
    virtual void write(uint8_t* buf, uint64_t val) const = 0;
    // 按需扩展其他接口
};

// 32位实现
class Int32Handler : public BitIntHandler {
public:
    uint64_t read(const uint8_t* buf) const override {
        return *reinterpret_cast<const uint32_t*>(buf);
    }
    void write(uint8_t* buf, uint64_t val) const override {
        *reinterpret_cast<uint32_t*>(buf) = static_cast<uint32_t>(val);
    }
};

// 64位实现
class Int64Handler : public BitIntHandler {
public:
    uint64_t read(const uint8_t* buf) const override {
        return *reinterpret_cast<const uint64_t*>(buf);
    }
    void write(uint8_t* buf, uint64_t val) const override {
        *reinterpret_cast<uint64_t*>(buf) = val;
    }
};

// 工厂函数，启动时仅调用一次
std::unique_ptr<BitIntHandler> create_handler(uint8_t file_bit_flag) {
    switch(file_bit_flag) {
        case 1: return std::make_unique<Int32Handler>();
        case 2:
#if UINTPTR_MAX == 0xffffffff
            throw std::runtime_error("32位系统不支持64位生成的文件");
#endif
            return std::make_unique<Int64Handler>();
        default: throw std::invalid_argument("无效的文件位数标记");
    }
}

上层业务持有BitIntHandler智能指针，直接调用接口即可，无需感知底层实现。如果对性能要求较高，也可以使用std::variant存储两种实现，配合std::visit做静态分发，完全消除虚函数开销。

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