从文本文件读取浮点值遇非浮点数据后读取异常的解决思路

Hey, let's break down why your code is misbehaving and fix it properly!

The root cause of your problem is input stream error states. When dfile >> dat[i] tries to read a non-float value (like "somestring" in your example), the read operation fails, and this sets the stream's failbit flag. Once the stream is in an error state, all future read operations will skip immediately—those trailing zeros in your output aren't coming from the file; they're just the default initial values of your dat array, since no new data is being loaded after the first failure.

Here are two solid solutions that match your initial ideas, plus explanations of how they work:

Solution 1: Skip Non-Float Lines & Reset Stream State #

This approach fixes the stream state when a read fails, then skips the rest of the problematic line before continuing to read valid data.

#include <iostream>
#include <fstream>
#include <limits> // Required for numeric_limits

using namespace std;

int main() {
    ifstream dfile("Datafile.txt");
    ofstream ofile("Output.txt");
    float dat[100]; // Adjust size as needed
    int i = 0;
    string dummy_col; // Holds the useless first column
    float target_value;

    // Keep going as long as we can read the first column
    while (dfile >> dummy_col) {
        // Try to read the second column as a float
        if (dfile >> target_value) {
            dat[i] = target_value;
            ofile << dat[i] << endl;
            cout << dat[i] << endl;
            i++;
        } else {
            // Reset the stream's error state
            dfile.clear();
            // Skip all characters until the end of the current line
            dfile.ignore(numeric_limits<streamsize>::max(), '\n');
            // Optional: Uncomment to log skipped lines
            // cout << "Skipped a line with non-float data" << endl;
        }
    }

    dfile.close();
    ofile.close();
    return 0;
}

This code first reads the first column (no matter what it is), then attempts to parse the second column as a float. If that works, we save the value; if not, we clear the stream's error flag and jump to the next line, so valid floats later in the file get read correctly.

Solution 2: Read Entire Lines & Parse Them Individually #

If your float values follow a predictable sequence, reading full lines first and parsing each line separately is even more robust. This isolates errors to individual lines, so one bad line won't break the entire stream.

#include <iostream>
#include <fstream>
#include <string>
#include <sstream>

using namespace std;

int main() {
    ifstream dfile("Datafile.txt");
    ofstream ofile("Output.txt");
    float dat[100];
    int i = 0;
    string line;

    // Read one line at a time until the end of the file
    while (getline(dfile, line)) {
        istringstream line_parser(line);
        string dummy_col;
        float target_value;

        line_parser >> dummy_col; // Skip the first column
        // Try to parse the second column as a float
        if (line_parser >> target_value) {
            dat[i] = target_value;
            ofile << dat[i] << endl;
            cout << dat[i] << endl;
            i++;
        }
        // No need to reset state here—each line uses its own parser
    }

    dfile.close();
    ofile.close();
    return 0;
}

By using getline to read full lines and istringstream to parse each one, we avoid messing up the main file stream's state. Each line is handled independently, so a non-float value only skips that single line.

Why Your Original Code Failed #

To recap: When the read of dat[i] failed on "somestring", the stream entered an error state. Your while(dfile.eof()) check didn't catch this properly (since eof() only triggers after a failed read past the end of the file), and all subsequent >> operations just failed silently. The zeros you saw were the uninitialized values of your dat array, not data from the file.

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