C++如何读取列长度不一致的数据？

Hey there! I see you've already nailed reading fixed-column data in C++, and now you need to handle cases where column lengths aren't consistent. Let's break this down into common real-world scenarios and walk through practical, robust implementations.

Scenario 1: Rows have variable numbers of columns #

If your data file has rows with differing counts of values (e.g., one row has 2 numbers, another has 5, another has 3), the best approach is to store each row's data as a sub-vector within a larger 2D container. This keeps all your data organized while accommodating the variable column counts.

Implementation Code #

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

int main() {
    std::ifstream dataFile("inputData.dat");
    if (!dataFile.is_open()) {
        std::cerr << "Error: Could not open input file!" << std::endl;
        return 1;
    }

    std::vector<std::vector<double>> allRows;
    std::string line;

    while (std::getline(dataFile, line)) {
        // Skip empty lines to avoid empty sub-vectors
        if (line.empty()) continue;

        std::istringstream lineStream(line);
        std::vector<double> currentRow;
        double value;

        // Extract all values from the current line until the stream is exhausted
        while (lineStream >> value) {
            currentRow.push_back(value);
        }

        if (!currentRow.empty()) {
            allRows.push_back(currentRow);
        }
    }

    // Verify the results (optional)
    std::cout << "Parsed " << allRows.size() << " rows of data:\n";
    for (const auto& row : allRows) {
        for (double val : row) {
            std::cout << val << " ";
        }
        std::cout << "\n";
    }

    dataFile.close();
    return 0;
}

How It Works #

• We read each line individually, then use std::istringstream to extract every numeric value from that line, regardless of how many there are.
• Each row's values are stored in a sub-vector, which is then added to the main 2D vector allRows.
• Empty lines are skipped to avoid cluttering the data structure.

Scenario 2: Columns have different total row counts (segmented data) #

If your file stores all values for one column first, then all values for the next (e.g., 10 entries for heights, followed by 8 entries for times), you'll need a way to distinguish when one column ends and the next begins. Using header markers (like # Heights) is a clean way to handle this.

Implementation Code #

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

int main() {
    std::ifstream dataFile("inputData.dat");
    if (!dataFile.is_open()) {
        std::cerr << "Error: Could not open input file!" << std::endl;
        return 1;
    }

    std::vector<double> heights, times, stdDevs;
    std::string line;

    // Track which column we're currently reading
    enum class ActiveColumn { None, Heights, Times, StdDevs } currentCol = ActiveColumn::None;

    while (std::getline(dataFile, line)) {
        if (line.empty()) continue;

        // Check for column header markers
        if (line.starts_with("#")) {
            if (line.find("Heights") != std::string::npos) {
                currentCol = ActiveColumn::Heights;
            } else if (line.find("Times") != std::string::npos) {
                currentCol = ActiveColumn::Times;
            } else if (line.find("StdDevs") != std::string::npos) {
                currentCol = ActiveColumn::StdDevs;
            } else {
                currentCol = ActiveColumn::None;
            }
            continue;
        }

        // Parse and store the value if we're in a valid column section
        std::istringstream lineStream(line);
        double value;
        if (lineStream >> value) {
            switch (currentCol) {
                case ActiveColumn::Heights:
                    heights.push_back(value);
                    break;
                case ActiveColumn::Times:
                    times.push_back(value);
                    break;
                case ActiveColumn::StdDevs:
                    stdDevs.push_back(value);
                    break;
                default:
                    std::cerr << "Warning: Ignoring uncategorized value: " << value << "\n";
                    break;
            }
        } else {
            std::cerr << "Warning: Invalid numeric data in line: " << line << "\n";
        }
    }

    // Verify results
    std::cout << "Heights (" << heights.size() << " entries): ";
    for (double h : heights) std::cout << h << " ";
    std::cout << "\nTimes (" << times.size() << " entries): ";
    for (double t : times) std::cout << t << " ";
    std::cout << "\nStdDevs (" << stdDevs.size() << " entries): ";
    for (double s : stdDevs) std::cout << s << " ";
    std::cout << "\n";

    dataFile.close();
    return 0;
}

How It Works #

• We use an enum to track which column we're actively reading.
• Header lines (starting with #) trigger a switch to the corresponding column.
• Numeric values are routed to the appropriate vector based on the active column.
• Error handling is added to warn about invalid data or uncategorized values.

Bonus: Sparse columns (some rows missing later values) #

If most rows have 3 values, but some only have 1 or 2, and you want to store each position in its own vector (even if some vectors are shorter), you can explicitly check for each value:

std::vector<double> col1, col2, col3;
std::string line;

while (std::getline(dataFile, line)) {
    std::istringstream ss(line);
    double v1, v2, v3;
    bool hasV1 = (ss >> v1);
    bool hasV2 = (ss >> v2);
    bool hasV3 = (ss >> v3);

    if (hasV1) col1.push_back(v1);
    if (hasV2) col2.push_back(v2);
    if (hasV3) col3.push_back(v3);
}

This way, col3 will only contain values from rows that had a third entry.

Key Notes #

• Always include error handling for file opening and invalid numeric input to avoid silent failures or crashes.
• If your file has no clear markers for column boundaries, you can hardcode column lengths (if you know them upfront) or add logic to detect transitions between columns.

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