二进制文件读取至动态数组出现垃圾值问题求助

Hey there! Let's work through this binary file I/O issue you're hitting—seeing garbage values after the first chunk of data is a super common pitfall with dynamic arrays and fstream, so let's break down the most likely fixes.

Common Causes & Fixes #

1. Forgetting Binary Mode When Opening the File #

Text mode (the default for fstream) messes with binary data by translating newline characters and other special bytes. This corrupts your records before you even read them. Always add ios::binary when opening files for binary I/O:

// Correct way to open for write
fstream inve("your_file.dat", ios::out | ios::binary);
// Correct way to open for read
fstream inve("your_file.dat", ios::in | ios::binary);

2. Mismatched Write/Read Sizes #

If you're writing structs or custom record types, make sure you're writing and reading the exact same number of bytes per record. For example, when using write() and read(), pass sizeof(YourRecordType) as the byte count:

// Writing a single record
inve.write(reinterpret_cast<char*>(&yourRecord), sizeof(YourRecord));

// Reading into dynamic array element
inve.read(reinterpret_cast<char*>(&dynamicArray[i]), sizeof(YourRecord));

Avoid partial writes/reads—this will leave leftover bytes in your array that look like garbage.

3. Not Resetting the File Pointer After Writing #

If you're writing to the file and then immediately reading from it without resetting the pointer, you'll start reading from the end of the file (where there's no valid data). Add this after writing to jump back to the start:

inve.seekg(0, ios::beg); // Move read pointer to beginning of file

4. Dynamic Array Memory Misallocation #

Double-check that your dynamic array has enough space for all records. Calculate the number of records first by getting the file size, then allocate accordingly:

// Get total file size
inve.seekg(0, ios::end);
streampos fileSize = inve.tellg();
inve.seekg(0, ios::beg);

// Calculate number of records
int recordCount = fileSize / sizeof(YourRecord);

// Allocate exact memory needed
YourRecord* dynamicArray = new YourRecord[recordCount];

Allocating too little memory will cause overflow, leading to garbage values. Don't forget to delete[] the array when you're done to avoid leaks!

5. Compiler Struct Padding #

If your records are structs, compilers often add padding bytes to align data, which makes sizeof(YourStruct) larger than the sum of its members. This mismatch between write and read sizes causes garbage data. Disable padding with compiler directives:

#pragma pack(push, 1) // Disable padding
struct InventoryRecord {
    int itemId;
    char itemName[30];
    double price;
};
#pragma pack(pop) // Restore default padding

Example Working Code Snippet #

Here's a quick example tying these fixes together:

#include <fstream>
#include <iostream>

#pragma pack(push, 1)
struct InventoryRecord {
    int itemId;
    char itemName[30];
    double price;
};
#pragma pack(pop)

int main() {
    // Write records to file
    fstream inve("inventory.dat", ios::out | ios::binary);
    if (inve.is_open()) {
        InventoryRecord items[] = {
            {1, "Laptop", 999.99},
            {2, "Mouse", 24.99},
            {3, "Keyboard", 49.99}
        };
        for (auto& item : items) {
            inve.write(reinterpret_cast<char*>(&item), sizeof(InventoryRecord));
        }
        inve.close();
    }

    // Read records to dynamic array
    inve.open("inventory.dat", ios::in | ios::binary);
    if (inve.is_open()) {
        inve.seekg(0, ios::end);
        streampos fileSize = inve.tellg();
        inve.seekg(0, ios::beg);

        int recordCount = fileSize / sizeof(InventoryRecord);
        InventoryRecord* dynamicArray = new InventoryRecord[recordCount];

        for (int i = 0; i < recordCount; ++i) {
            inve.read(reinterpret_cast<char*>(&dynamicArray[i]), sizeof(InventoryRecord));
        }

        // Print formatted output
        for (int i = 0; i < recordCount; ++i) {
            std::cout << "Item " << i+1 << ": ID=" << dynamicArray[i].itemId 
                      << ", Name=" << dynamicArray[i].itemName 
                      << ", Price=" << dynamicArray[i].price << "\n";
        }

        delete[] dynamicArray;
        inve.close();
    }
    return 0;
}

Start by verifying these points one by one—binary mode and file pointer reset are usually the first culprits. Let me know if you need to adjust this based on your specific record structure!

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