如何在 C++ 中从具有不同行大小的文件中读取一行？答案

【问题标题】：how to read a line from file with different line size in c++?如何在 C++ 中从具有不同行大小的文件中读取一行？
【发布时间】：2019-12-18 07:03:43
【问题描述】：

我正在尝试读取这样的文件

2                   #number of process

1                   #process name
0 1000              #start and finsh time of process
1 400               #number of memmory #memmory size

2                   #process name
0 2000              #start and finsh time of process
2 200 400           #number of memmory #memmory size

进程数和内存数可以不同我的主要问题是如何从不同数量的内存中读取文件？

【问题讨论】：

您的number of processes 是文件中的一种标题。您可以轻松读取此值并开始循环。在每个循环中，您可以从流中逐行读取值，并在number of memory 的内部循环的帮助下，您将能够读取您的文件。
你知道每一行有多少个数字，它是第一个数字。

标签： c++ file readfile

【解决方案1】：

假设输入文件格式正确且不包含任何错误，您可以按原样读取数字，然后使用循环读取可变数量的记录或值。

大概是这样的：

int process_count;
file >> process_count;

for (unsigned p = 0; p < process_count; ++p)
{
    int process_name, start_time, finish_time, memory_count;
    std::vector<int> memory;

    file >> process_name >> start_time >> finish_time >> memory_count;

    for (unsigned m = 0; m < memory_count; ++m)
    {
        int memory_size;
        file >> memory_size;
        memory.push_back(memory_size);
    }

    // Here all data for the "process" have been read from the file, use it...
}

【讨论】：

【解决方案2】：

我会定义一种类型来保留一个进程的信息，然后为该类型添加流式操作符。收集到的进程非常适合存储在 std::vector 中。

例子：

#include <ctime>
#include <iostream>
#include <iterator>
#include <sstream>
#include <vector>

// define a type for a process entry
struct process {
    long name;
    std::time_t start;
    std::time_t end;
    // a vector for all your memory sizes:
    std::vector<std::size_t> mem_sizes;
};

// operator for reading one process from a stream
std::istream& operator>>(std::istream& is, process& p) {
    if(unsigned number_of_memory;
       is >> p.name >> p.start >> p.end >> number_of_memory)
    {
        p.mem_sizes.clear(); // remove any old memory sizes

        for(std::size_t tmp; number_of_memory && is >> tmp; --number_of_memory) {
            p.mem_sizes.push_back(tmp);
        }
    }
    return is;
}

// operator for writing one process to a stream
std::ostream& operator<<(std::ostream& os, const process& p) {
    if(os << p.name << '\n'
          << p.start << ' ' << p.end << '\n'
          << p.mem_sizes.size())
    {
        for(std::size_t mem_size : p.mem_sizes) 
            os << ' ' << mem_size;
    }
    return os << '\n';
}

int main() {
    // example file
    std::istringstream file(
        "2\n"         // #number of process
        "\n"          //
        "1\n"         // #process name
        "0 1000\n"    // #start and finsh time of process
        "1 400\n"     // #number of memmory #memmory size
        "\n"          //
        "2\n"         // #process name
        "0 2000\n"    // #start and finsh time of process
        "2 200 400\n" // #number of memmory #memmory size
    );

    // collected processes
    std::vector<process> processes;

    // std::ifstream file("filename");
    if(file) {
        // read processes
        if(int process_count; file >> process_count) {
            for(process tmp; process_count && file >> tmp; --process_count) {
                processes.push_back(tmp);
            }
        }
    }

    // print the collected processes:
    std::cout << processes.size() << '\n';
    for(const process& p : processes) {
        std::cout << '\n' << p;
    }
}

【讨论】：