C++ 如何从c+中具有不同行大小的文件中读取行+；？

我正试图从这样的文件中读取

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

进程数和内存数可以不同

---

我的主要问题是如何从具有不同内存数的文件中读取数据？

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

也许是这样的：

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...
}

int进程\u计数；
文件>>进程计数；
for（无符号p=0；p>进程名称>>开始时间>>完成时间>>内存计数；
for（无符号m=0；m<内存计数；++m）
{
内存大小；
文件>>内存大小；
内存。推回（内存大小）；
}
//这里所有的“进程”数据都已从文件中读取，请使用它。。。
}

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

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;
    }
}

#包括
#包括
#包括
#包括
#包括
//定义流程条目的类型
结构过程{
长名称；
std：：启动时间；
标准：时间结束；
//所有内存大小的向量：
std：：向量内存大小；
};
//用于从流中读取一个进程的运算符
std:：istream&operator>>（std:：istream&is，过程与工艺）{
if（内存的无符号数）；
is>>p.name>>p.start>>p.end>>内存的数量）
{
p、 mem_size.clear（）；//删除所有旧的内存大小
for（std:：size\t tmp；内存的数量&&is>>tmp；--内存的数量）{
p、 记忆大小。推回（tmp）；
}
}
回报是；
}
//用于将一个进程写入流的运算符
std:：ostream&operatorYour
进程数
是文件中的一种头。您可以轻松读取该值并开始循环。在每个循环中，您可以从流中逐行读取值，借助
内存数的内部循环，您将能够读取文件。您知道每行上有多少个数字，它是第一个数字。