c++ - 在 C/C++ 中从文件中读取最后 n 行

Question

我看过很多帖子，但没有找到我想要的东西。
我得到错误的输出：

ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ......  // may be this is EOF character

进入无限循环。

我的算法：

1. 转到文件末尾。
2. 将指针的位置减 1 并逐字符读取。
3. 如果我们找到我们的 10 行或者我们到达文件的开头，则退出。
4. 现在我将扫描整个文件直到 EOF 并打印它们//未在代码中实现。

代码：

#include<iostream>
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<string.h>

using namespace std;
int main()
{
    FILE *f1=fopen("input.txt","r");
    FILE *f2=fopen("output.txt","w");
    int i,j,pos;
        int count=0;
        char ch;
        int begin=ftell(f1);
        // GO TO END OF FILE
        fseek(f1,0,SEEK_END);
        int end = ftell(f1);
        pos=ftell(f1);

        while(count<10)
        {
            pos=ftell(f1);
            // FILE IS LESS THAN 10 LINES
            if(pos<begin)
                break;
            ch=fgetc(f1);
            if(ch=='\n')
                count++;
            fputc(ch,f2);
            fseek(f1,pos-1,end);
        }
    return 0;
}

更新 1：

更改代码：它现在只有 1 个错误 - 如果输入有类似的行

3enil
2enil
1enil

it prints 10 lines only

line1
line2
line3ÿine1
line2
line3ÿine1
line2
line3ÿine1
line2
line3ÿine1
line2

PS:
1. 在记事本++中处理windows

1. 这不是作业

2. 我也想在不使用更多内存或使用 STL 的情况下做到这一点。

3. 我正在练习以提高我的基础知识，所以请不要发布任何功能（如tail -5 tc。）

请帮助改进我的代码。

Answer 1

代码中的注释

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    FILE *in, *out;
    int count = 0;
    long int pos;
    char s[100];

    in = fopen("input.txt", "r");
    /* always check return of fopen */
    if (in == NULL) {
        perror("fopen");
        exit(EXIT_FAILURE);
    }
    out = fopen("output.txt", "w");
    if (out == NULL) {
        perror("fopen");
        exit(EXIT_FAILURE);
    }
    fseek(in, 0, SEEK_END);
    pos = ftell(in);
    /* Don't write each char on output.txt, just search for '\n' */
    while (pos) {
        fseek(in, --pos, SEEK_SET); /* seek from begin */
        if (fgetc(in) == '\n') {
            if (count++ == 10) break;
        }
    }
    /* Write line by line, is faster than fputc for each char */
    while (fgets(s, sizeof(s), in) != NULL) {
        fprintf(out, "%s", s);
    }
    fclose(in);
    fclose(out);
    return 0;
}

Answer 2

您的代码存在许多问题。最重要的是，您永远不会检查任何功能是否成功。并且将结果保存ftell在一个int中也不是一个好主意。然后是测试pos < begin；只有在出现错误时才会发生这种情况。而且您将结果fgetc放入 a 中char（这会导致信息丢失）。事实上，您所做的第一次读取是在文件末尾，所以会失败（一旦流进入错误状态，它就会停留在那里）。ftell如果文件以文本模式打开，则无法可靠地对（Unix 下除外）返回的值进行算术运算。

哦，没有“EOF 字符”；'ÿ'是一个完全有效的字符（Latin-1 中的 0xFF）。一旦将返回值分配fgetc给 a char，您就失去了测试文件结尾的任何可能性。

我可能会补充一点，一次向后阅读一个字符是非常低效的。通常的解决方案是分配一个足够大的缓冲区，然后'\n'在其中计数。

编辑：

只需一点代码即可给出这个想法：

std::string
getLastLines( std::string const& filename, int lineCount )
{
    size_t const granularity = 100 * lineCount;
    std::ifstream source( filename.c_str(), std::ios_base::binary );
    source.seekg( 0, std::ios_base::end );
    size_t size = static_cast<size_t>( source.tellg() );
    std::vector<char> buffer;
    int newlineCount = 0;
    while ( source 
            && buffer.size() != size
            && newlineCount < lineCount ) {
        buffer.resize( std::min( buffer.size() + granularity, size ) );
        source.seekg( -static_cast<std::streamoff>( buffer.size() ),
                      std::ios_base::end );
        source.read( buffer.data(), buffer.size() );
        newlineCount = std::count( buffer.begin(), buffer.end(), '\n');
    }
    std::vector<char>::iterator start = buffer.begin();
    while ( newlineCount > lineCount ) {
        start = std::find( start, buffer.end(), '\n' ) + 1;
        -- newlineCount;
    }
    std::vector<char>::iterator end = remove( start, buffer.end(), '\r' );
    return std::string( start, end );
}

这在错误处理方面有点弱；特别是，您可能想要区分无法打开文件和任何其他错误。（应该不会发生其他错误，但你永远不知道。）

此外，这纯粹是 Windows，它假定实际文件包含纯文本，并且不包含任何'\r'不属于 CRLF 的内容。（对于 Unix，只需将下一行放到最后一行。）

Answer 3

这可以使用循环数组非常有效地完成。不需要额外的缓冲区。

void printlast_n_lines(char* fileName, int n){

    const int k = n;
    ifstream file(fileName);
    string l[k];
    int size = 0 ;

    while(file.good()){
        getline(file, l[size%k]); //this is just circular array
        cout << l[size%k] << '\n';
        size++;
    }

    //start of circular array & size of it 
    int start = size > k ? (size%k) : 0 ; //this get the start of last k lines 
    int count = min(k, size); // no of lines to print

    for(int i = 0; i< count ; i++){
        cout << l[(start+i)%k] << '\n' ; // start from in between and print from start due to remainder till all counts are covered
    }
}

请提供反馈。

Answer 4

我相信，你用fseek错了。检查man fseek谷歌。

尝试这个：

fseek(f1, -2, SEEK_CUR);
//1 to neutrialize change from fgect
//and 1 to move backward

您还应该将开头的位置设置为最后一个元素：

fseek(f1, -1, SEEK_END).

你不需要end变量。

fgetc您应该检查所有函数（fseek和ftell）的返回值。这是一个很好的做法。我不知道这段代码是否适用于空文件或类似的东西。

Answer 5

int end = ftell(f1);
pos=ftell(f1);

这告诉你文件的最后一点，所以 EOF。当您阅读时，您会收到 EOF 错误，并且 ppointer 想要向前移动 1 个空格...

所以，我建议将当前位置减一。或者将 fseek(f1, -2,SEEK_CUR) 放在 while 循环的开头，以弥补 fread 1 点并返回 1 点...

Answer 6

用途：fseek(f1,-2,SEEK_CUR);背

我写了这段代码，它可以工作，你可以试试：

#include "stdio.h"

int main()
{
        int count = 0;
        char * fileName = "count.c";
        char * outFileName = "out11.txt";
        FILE * fpIn;
        FILE * fpOut;
        if((fpIn = fopen(fileName,"r")) == NULL )
                printf(" file %s open error\n",fileName);
        if((fpOut = fopen(outFileName,"w")) == NULL )
                printf(" file %s open error\n",outFileName);
        fseek(fpIn,0,SEEK_END);
        while(count < 10)
        {
                fseek(fpIn,-2,SEEK_CUR);
                if(ftell(fpIn)<0L)
                        break;
                char now = fgetc(fpIn);
                printf("%c",now);
                fputc(now,fpOut);
                if(now == '\n')
                        ++count;
        }
        fclose(fpIn);
        fclose(fpOut);
}

Answer 7

这是 C++ 中的解决方案。

#include <iostream>                                                             
#include <string>                                                               
#include <exception>                                                            
#include <cstdlib>                                                              

int main(int argc, char *argv[])                                                
{                                                                               
    auto& file = std::cin;                                                      

    int n = 5;                                                                  
    if (argc > 1) {                                                             
        try {                                                                   
            n = std::stoi(argv[1]);                                             
        } catch (std::exception& e) {                                           
            std::cout << "Error: argument must be an int" << std::endl;         
            std::exit(EXIT_FAILURE);                                            
        }                                                                       
    }                                                                           

    file.seekg(0, file.end);                                                    

    n = n + 1; // Add one so the loop stops at the newline above                
    while (file.tellg() != 0 && n) {                                            
        file.seekg(-1, file.cur);                                               
        if (file.peek() == '\n')                                                
            n--;                                                                
    }                                                                           

    if (file.peek() == '\n') // If we stop in the middle we will be at a newline
        file.seekg(1, file.cur);                                                

    std::string line;                                                           
    while (std::getline(file, line))                                            
        std::cout << line << std::endl;                                         

    std::exit(EXIT_SUCCESS);                                                    
} 

建造：

$ g++ <SOURCE_NAME> -o last_n_lines

跑：

$ ./last_n_lines 10 < <SOME_FILE>

Answer 8

我将使用两个流来打印文件的最后 n 行：这在O(lines) runtime和O(lines) space中运行。

#include<bits/stdc++.h>
using namespace std;

int main(){
  // read last n lines of a file
  ifstream f("file.in");
  ifstream g("file.in");

  // move f stream n lines down.
  int n;
  cin >> n;
  string line;
  for(int i=0; i<k; ++i) getline(f,line);

  // move f and g stream at the same pace.
  for(; getline(f,line); ){
    getline(g, line);
  }

  // g now has to go the last n lines.
  for(; getline(g,line); )
    cout << line << endl;
}

具有O(lines) 运行时间和O(N) 空间的解决方案是使用队列：

ifstream fin("file.in");
int k;
cin >> k;
queue<string> Q;
string line;
for(; getline(fin, line); ){
  if(Q.size() == k){
    Q.pop();
  }
  Q.push(line);
}
while(!Q.empty()){
  cout << Q.front() << endl;
  Q.pop();
}