如何用ifstream读取非对齐TGA文件头至带填充结构体（无需强制非对齐）

嘿，这个问题我太熟了——结构体对齐填充确实是二进制文件读取时的坑，尤其是像TGA这种有严格固定字节布局的格式。不用强制非对齐分配的话，有几个既稳妥又跨平台的办法，给你捋一捋：

1. 手动逐个读取结构体成员 #

这是最直接也最不容易出错的方式，完全绕开结构体的对齐问题。你不需要一次性把整个结构体读入内存，而是按TGA头的实际字节顺序，逐个读取每个字段：

#include <fstream>

struct TARGA_HEADER {
    unsigned char IDLength;
    unsigned char ColorMapType;
    unsigned char ImageType;
    unsigned short FirstEntryIndex;
    unsigned short ColorMapLength;
    unsigned char ColorMapEntrySize;
    unsigned short XOrigin;
    unsigned short YOrigin;
    unsigned short Width;
    unsigned short Height;
    unsigned char PixelDepth;
    unsigned char ImageDescriptor;
};

int main() {
    std::ifstream file("image.tga", std::ios::binary);
    if (!file) { /* 处理打开失败 */ }

    TARGA_HEADER header;
    // 逐个读取每个成员，完全不受结构体填充影响
    file.read(reinterpret_cast<char*>(&header.IDLength), sizeof(header.IDLength));
    file.read(reinterpret_cast<char*>(&header.ColorMapType), sizeof(header.ColorMapType));
    file.read(reinterpret_cast<char*>(&header.ImageType), sizeof(header.ImageType));
    file.read(reinterpret_cast<char*>(&header.FirstEntryIndex), sizeof(header.FirstEntryIndex));
    file.read(reinterpret_cast<char*>(&header.ColorMapLength), sizeof(header.ColorMapLength));
    file.read(reinterpret_cast<char*>(&header.ColorMapEntrySize), sizeof(header.ColorMapEntrySize));
    file.read(reinterpret_cast<char*>(&header.XOrigin), sizeof(header.XOrigin));
    file.read(reinterpret_cast<char*>(&header.YOrigin), sizeof(header.YOrigin));
    file.read(reinterpret_cast<char*>(&header.Width), sizeof(header.Width));
    file.read(reinterpret_cast<char*>(&header.Height), sizeof(header.Height));
    file.read(reinterpret_cast<char*>(&header.PixelDepth), sizeof(header.PixelDepth));
    file.read(reinterpret_cast<char*>(&header.ImageDescriptor), sizeof(header.ImageDescriptor));

    // 之后处理读取的数据...
    return 0;
}

这种方式的核心是：你直接控制每个字段的读取位置，编译器给结构体加的填充字节根本不会被读取，自然就不会干扰文件数据的解析。

2. 封装专门的反序列化函数 #

如果你的项目需要多次读取TGA头，把读取逻辑封装成一个单独的函数会更整洁，还能顺便处理字节序问题（TGA是小端字节序，有些大端平台需要转换）：

#include <fstream>
#include <cstdint> // 用于uint16_t等类型

// 小端转主机字节序的辅助函数（如果平台支持C++20，可以直接用std::le16toh）
uint16_t le_to_host16(uint16_t le_value) {
    #if defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
        return le_value;
    #else
        return (le_value >> 8) | (le_value << 8);
    #endif
}

bool read_targa_header(std::ifstream& file, TARGA_HEADER& header) {
    if (!file.is_open()) return false;

    // 读取单字节成员
    file.read(reinterpret_cast<char*>(&header.IDLength), 1);
    file.read(reinterpret_cast<char*>(&header.ColorMapType), 1);
    file.read(reinterpret_cast<char*>(&header.ImageType), 1);

    // 读取双字节成员，处理字节序
    uint16_t temp;
    file.read(reinterpret_cast<char*>(&temp), 2);
    header.FirstEntryIndex = le_to_host16(temp);

    file.read(reinterpret_cast<char*>(&temp), 2);
    header.ColorMapLength = le_to_host16(temp);

    file.read(reinterpret_cast<char*>(&header.ColorMapEntrySize), 1);

    file.read(reinterpret_cast<char*>(&temp), 2);
    header.XOrigin = le_to_host16(temp);

    file.read(reinterpret_cast<char*>(&temp), 2);
    header.YOrigin = le_to_host16(temp);

    file.read(reinterpret_cast<char*>(&temp), 2);
    header.Width = le_to_host16(temp);

    file.read(reinterpret_cast<char*>(&temp), 2);
    header.Height = le_to_host16(temp);

    file.read(reinterpret_cast<char*>(&header.PixelDepth), 1);
    file.read(reinterpret_cast<char*>(&header.ImageDescriptor), 1);

    return file.good();
}

这个函数把读取和字节序转换逻辑都封装起来，代码复用性更高，也更符合工程化的写法。

3. 先读字节缓冲区再解析 #

另一种思路是先把整个TGA头（标准大小是18字节）读到一个字节数组里，再按偏移量逐个解析到结构体成员中。这种方式适合你想完全控制每个字节的解析过程：

#include <fstream>
#include <array>

constexpr size_t TGA_HEADER_BYTES = 18;

int main() {
    std::ifstream file("image.tga", std::ios::binary);
    if (!file) { /* 处理打开失败 */ }

    std::array<unsigned char, TGA_HEADER_BYTES> header_buf;
    file.read(reinterpret_cast<char*>(header_buf.data()), TGA_HEADER_BYTES);

    TARGA_HEADER header;
    size_t offset = 0;

    // 解析单字节字段
    header.IDLength = header_buf[offset++];
    header.ColorMapType = header_buf[offset++];
    header.ImageType = header_buf[offset++];

    // 解析双字节字段（小端序，低字节在前）
    header.FirstEntryIndex = (header_buf[offset+1] << 8) | header_buf[offset];
    offset += 2;

    header.ColorMapLength = (header_buf[offset+1] << 8) | header_buf[offset];
    offset += 2;

    header.ColorMapEntrySize = header_buf[offset++];

    header.XOrigin = (header_buf[offset+1] << 8) | header_buf[offset];
    offset += 2;

    header.YOrigin = (header_buf[offset+1] << 8) | header_buf[offset];
    offset += 2;

    header.Width = (header_buf[offset+1] << 8) | header_buf[offset];
    offset += 2;

    header.Height = (header_buf[offset+1] << 8) | header_buf[offset];
    offset += 2;

    header.PixelDepth = header_buf[offset++];
    header.ImageDescriptor = header_buf[offset++];

    // 后续处理...
    return 0;
}

这种方式的好处是你能清晰看到每个字段对应的字节位置，排查问题时更方便，而且完全不依赖结构体的内存布局。

以上几种办法都不需要修改编译器的对齐设置，既保证了代码的可移植性，又彻底解决了结构体填充导致的读取错误问题。

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