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

Posted 2023-02-21

【中文标题】如何在 C++ 中从具有不同行大小的文件中读取一行？

【英文标题】：how to read a line from file with different line size in 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 的内部循环的帮助下，您将能够读取您的文件。

你知道每一行有多少个数字，它是第一个数字。

【参考方案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;