C++怎么操作二进制文件 C++二进制文件读写的方法详解

c++++操作二进制文件的核心是使用fstream库并以二进制模式打开文件。1. 写入二进制文件需创建ofstream对象并使用ios::binary标志，通过write()方法写入数据，注意用reinterpret_cast将数据地址转为const char类型；2. 读取二进制文件需创建ifstream对象并同样使用ios::binary标志，通过read()方法读取数据，注意用reinterpret_cast将数据地址转为char类型；3. 处理结构体数组时，循环逐个读写每个结构体；4. 处理字符串时，先写入字符串长度再写入内容，读取时先读长度再分配内存读取字符；5. 解决大端小端问题可通过htonl/ntohl等函数统一字节序；6. 优化性能的方法包括使用缓冲区、批量读写、避免频繁打开关闭文件及使用内存映射文件。这些方法确保了对复杂数据如图像、音频的高效处理，并解决了底层数据表示和传输一致性问题。

C++操作二进制文件，核心在于使用fstream库，并以二进制模式打开文件。读写时，需要理解数据在内存中的表示方式，并将其直接写入或读取到文件中。这比文本文件操作更底层，但也更灵活，适合处理图像、音频等复杂数据。

C++提供了多种方法来操作二进制文件，下面详细介绍读写二进制文件的方法，并解答一些常见问题。

解决方案

立即学习“C++免费学习笔记（深入）”；

C++使用fstream库中的ifstream和ofstream类来分别进行二进制文件的读取和写入。关键在于打开文件时使用ios::binary标志，以及使用read()和write()方法进行数据的读写。

写入二进制文件

1. 包含头文件: #include
2. 创建ofstream对象: ofstream outfile("filename.bin", ios::binary);
3. 检查文件是否成功打开: if (outfile.is_open()) { ... }
4. 使用write()方法写入数据: outfile.write(reinterpret_cast(&data), sizeof(data)); 这里data是要写入的变量，需要使用reinterpret_cast将变量的地址转换为const char*类型，sizeof(data)指定要写入的字节数。
5. 关闭文件: outfile.close();

读取二进制文件

1. 包含头文件: #include
2. 创建ifstream对象: ifstream infile("filename.bin", ios::binary);
3. 检查文件是否成功打开: if (infile.is_open()) { ... }
4. 使用read()方法读取数据: infile.read(reinterpret_cast(&data), sizeof(data)); 与写入类似，需要使用reinterpret_cast将变量的地址转换为char*类型，sizeof(data)指定要读取的字节数。
5. 检查是否读取到文件末尾: infile.eof() 可以用来判断是否已经读取到文件末尾。
6. 关闭文件: infile.close();

示例代码

Wegic

AI网页设计和开发工具

下载

#include 
#include 

using namespace std;

struct MyData {
    int id;
    double value;
};

int main() {
    // 写入二进制文件
    MyData data1 = {1, 3.14};
    ofstream outfile("mydata.bin", ios::binary);
    if (outfile.is_open()) {
        outfile.write(reinterpret_cast(&data1), sizeof(data1));
        outfile.close();
        cout << "Data written to file." << endl;
    } else {
        cerr << "Unable to open file for writing." << endl;
        return 1;
    }

    // 读取二进制文件
    MyData data2;
    ifstream infile("mydata.bin", ios::binary);
    if (infile.is_open()) {
        infile.read(reinterpret_cast(&data2), sizeof(data2));
        infile.close();
        cout << "Data read from file: id = " << data2.id << ", value = " << data2.value << endl;
    } else {
        cerr << "Unable to open file for reading." << endl;
        return 1;
    }

    return 0;
}

如何处理二进制文件中的结构体数组？

处理结构体数组，实际上就是循环读写结构体。写入时，循环遍历数组，将每个结构体写入文件；读取时，预先分配好结构体数组的空间，然后循环读取，直到文件末尾。

// 写入结构体数组
MyData dataArray[3] = {{1, 3.14}, {2, 2.71}, {3, 1.618}};
ofstream outfile("mydata_array.bin", ios::binary);
if (outfile.is_open()) {
    for (int i = 0; i < 3; ++i) {
        outfile.write(reinterpret_cast(&dataArray[i]), sizeof(MyData));
    }
    outfile.close();
    cout << "Data array written to file." << endl;
}

// 读取结构体数组
MyData readArray[3];
ifstream infile("mydata_array.bin", ios::binary);
if (infile.is_open()) {
    for (int i = 0; i < 3; ++i) {
        infile.read(reinterpret_cast(&readArray[i]), sizeof(MyData));
        if (infile.eof()) break; // 避免读取到文件末尾后的错误
        cout << "Data read from file: id = " << readArray[i].id << ", value = " << readArray[i].value << endl;
    }
    infile.close();
}

二进制文件读写中，如何处理字符串？

字符串的处理需要特别注意，因为C++中的std::string对象内部包含指针，直接写入std::string对象到文件，只会写入指针的值，而不是字符串的内容。正确的做法是写入字符串的长度和内容。

写入字符串

1. 先写入字符串的长度（例如，使用unsigned int存储长度）。
2. 然后写入字符串的内容。

读取字符串

1. 先读取字符串的长度。
2. 根据读取的长度，分配内存空间。
3. 读取字符串的内容到分配的内存中。
4. 使用读取的内容构造std::string对象。

// 写入字符串
string myString = "Hello, binary file!";
ofstream outfile("string.bin", ios::binary);
if (outfile.is_open()) {
    unsigned int length = myString.length();
    outfile.write(reinterpret_cast(&length), sizeof(length));
    outfile.write(myString.c_str(), length);
    outfile.close();
    cout << "String written to file." << endl;
}

// 读取字符串
string readString;
ifstream infile("string.bin", ios::binary);
if (infile.is_open()) {
    unsigned int length;
    infile.read(reinterpret_cast(&length), sizeof(length));
    char* buffer = new char[length + 1]; // +1 for null terminator
    infile.read(buffer, length);
    buffer[length] = '\0'; // Null terminate the string
    readString = buffer;
    delete[] buffer;
    infile.close();
    cout << "String read from file: " << readString << endl;
}

如何处理大端和小端问题？

大端和小端指的是数据在内存中存储时字节的顺序。如果写入数据和读取数据的机器的字节序不同，就会出现问题。

解决方案：

1. 统一字节序： 在写入文件之前，将数据转换为统一的字节序（例如，网络字节序，通常是大端）。在读取文件之后，再将数据转换回本地字节序。可以使用htonl()、htons()、ntohl()、ntohs()等函数进行转换。这些函数在 (Linux/Unix) 或 (Windows) 中定义。
2. 检测字节序： 在程序中检测机器的字节序，然后根据字节序进行相应的处理。

#include 
#include 
#include  // For uint32_t
#ifdef _WIN32
#include  // For htonl, ntohl on Windows
#pragma comment(lib, "ws2_32.lib") // Link with winsock2 library
#else
#include  // For htonl, ntohl on Linux/Unix
#endif

using namespace std;

// Function to check endianness
bool isLittleEndian() {
    uint32_t i = 0x01234567;
    // If the first byte is 0x67, then the system is little endian
    return (*((uint8_t*)&i)) == 0x67;
}


int main() {
    uint32_t value = 0x12345678;

    // Write to file in network byte order (big-endian)
    ofstream outfile("endian.bin", ios::binary);
    if (outfile.is_open()) {
        uint32_t networkValue = htonl(value); // Convert to network byte order
        outfile.write(reinterpret_cast(&networkValue), sizeof(networkValue));
        outfile.close();
        cout << "Value written in network byte order." << endl;
    }

    // Read from file and convert back to host byte order
    uint32_t readValue;
    ifstream infile("endian.bin", ios::binary);
    if (infile.is_open()) {
        infile.read(reinterpret_cast(&readValue), sizeof(readValue));
        readValue = ntohl(readValue); // Convert back to host byte order
        infile.close();
        cout << "Value read in host byte order: 0x" << hex << readValue << dec << endl;
    }

    return 0;
}

如何优化二进制文件读写性能？

二进制文件读写性能优化主要集中在减少磁盘I/O操作。

1. 使用缓冲区： fstream默认使用缓冲区，但可以手动设置更大的缓冲区。例如，使用file.rdbuf()->pubsetbuf(buffer, bufferSize)设置缓冲区。
2. 批量读写： 一次性读取或写入多个数据，而不是逐个读取或写入。
3. 避免频繁打开和关闭文件： 尽可能一次性完成所有的读写操作，避免频繁地打开和关闭文件。
4. 使用内存映射文件： 对于大型文件，可以使用内存映射文件（mmap），将文件映射到内存中，直接在内存中进行操作，可以显著提高读写性能。

#include 
#include 
#include 

using namespace std;

int main() {
    // 批量写入数据
    vector data(1000000, 42); // 1 million integers
    ofstream outfile("large_data.bin", ios::binary);
    if (outfile.is_open()) {
        outfile.write(reinterpret_cast(data.data()), data.size() * sizeof(int));
        outfile.close();
        cout << "Large data written to file." << endl;
    }

    // 批量读取数据
    vector readData(1000000);
    ifstream infile("large_data.bin", ios::binary);
    if (infile.is_open()) {
        infile.read(reinterpret_cast(readData.data()), readData.size() * sizeof(int));
        infile.close();
        cout << "Large data read from file." << endl;
    }

    return 0;
}

总而言之，C++操作二进制文件需要理解数据类型在内存中的表示，并使用fstream库提供的read()和write()方法进行读写。处理字符串时需要注意长度信息，处理字节序问题时需要进行相应的转换。通过使用缓冲区、批量读写等方法可以优化读写性能。