Определить, является ли строка последней строкой файла, используя только один цикл?

Вместо использования двух циклов было бы более эффективно всегда читать две строки заранее и обрабатывать строку только после того, как следующая строка будет успешно прочитана. Таким образом, последняя строка не будет обработана.

Вот пример:

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

#define LINEMAXLEN 30

//forward function declarations
void process_line( const char *line );
bool read_start_of_line_and_discard_rest( char buffer[], int buffer_size, FILE *fp );

int main( void )
{
    FILE *fp;
    char lines[2][LINEMAXLEN];

    //This index specifies which index in the array "lines"
    //represents the newest line. The other index is the
    //index of the previous line.
    int newest_index = 0;

    //attempt to open file
    fp = fopen( "input.txt", "r" );
    if ( fp == NULL )
    {
        fprintf( stderr, "Error opening file!\n" );
        exit( EXIT_FAILURE );
    }

    //read first line
    if ( !read_start_of_line_and_discard_rest( lines[newest_index], LINEMAXLEN, fp ) )
    {
        fprintf( stderr, "Error reading first line!\n" );
        exit( EXIT_FAILURE );
    }

    //process one line per loop iteration
    for (;;)
    {
        //swap the index, so that the newest line is now the
        //previous line
        newest_index = !newest_index;

        //read the new line
        if ( !read_start_of_line_and_discard_rest( lines[newest_index], LINEMAXLEN, fp ) )
        {
            //we have reached end-of-file, so we don't process the 
            //previous line, because that line is the last line
            break;
        }

        //since reading in a new line succeeded, we can be sure that
        //the previous line is not the last line, so we can process
        //the previous line

        //process the previous line
        process_line( lines[!newest_index] );
    }

    //cleanup
    fclose( fp );
}

//This function will process a line after it has been read
//from the input file. For now, it will only print it.
void process_line( const char *line )
{
    printf( "Processing line: %s\n", line );
}

//This function will read exactly one line of input and remove the
//newline character, if it exists. On success, it will return true.
//If this function is unable to read any further lines due to
//end-of-file, it returns false. If it fails for any other reason, it
//will not return, but will print an error message and call "exit"
//instead.
//If the line is too long to fit in the buffer, it will discard
//the rest of the line and report success.
bool read_start_of_line_and_discard_rest( char buffer[], int buffer_size, FILE *fp )
{
    char *p;

    //attempt to read one line from the stream
    if ( fgets( buffer, buffer_size, fp ) == NULL )
    {
        if ( ferror( fp ) )
        {
            fprintf( stderr, "Input error!\n" );
            exit( EXIT_FAILURE );
        }

        return false;
    }

    //determine whether line was too long for input buffer
    p = strchr( buffer, '\n' );
    if ( p == NULL )
    {
        int c;

        //discard remainder of line
        do
        {
            c = getchar();

        } while ( c != EOF && c != '\n' );
    }
    else
    {
        //remove newline character by overwriting it with a null
        //character
        *p = '\0';
    }

    return true;
}

Для ввода

This is line1.
This is line2 which has an additional length longer than 30 characters.
This is line3.
This is line4.

Эта программа имеет следующий вывод:

Processing line: This is line1.
Processing line: This is line2 which has an ad
Processing line: This is line3.

Как видите, обрабатываются все строки, кроме последней, и только первые LINEMAXLEN-1 (30-1 в моем примере) символы каждой строки обрабатываются/сохраняются. Остальные символы отбрасываются.

Обрабатываются/сохраняются только символы LINEMAXLEN-1 вместо LINEMAXLEN из каждой строки, поскольку для хранения завершающего нулевого символа требуется один символ.

Это довольно просто сделать в одном цикле, если мы используем чередующиеся буферы [как уже упоминалось другими].

В цикле ниже мы читаем строку в «текущий» буфер. Если не первая строка, мы обрабатываем предыдущую строку в «другом» буфере.

Чередуя индекс в пуле буферов из двух буферов, мы избегаем ненужного копирования.

Это вносит задержку в обработку буфера. На последней итерации последняя строка будет в текущем буфере, но не будет обработана.

#define LINEMAXLEN      1000            // line length of buffer
#define NBUF            2               // number of buffers

char lines[NBUF][LINEMAXLEN];           // buffer pool

int previdx = -1;                       // index of bufs for _previous_ line
int curidx = 0;                         // index of bufs for _current_ line
char *buf;                              // pointer to line buffer to process

// read all lines into alternating line buffers
for (;  fgets(lines[curidx],LINEMAXLEN,stdin) != NULL;
    previdx = curidx, curidx = (curidx + 1) % NBUF) {

    // process _previous_ line  ...
    if (previdx >= 0) {
        buf = lines[previdx];
        // process line ...
    }
}

Fgets() вообще не изменит буфер, когда он достигнет EOF, поэтому просто читайте строки, пока fgets() не вернет NULL. Последняя прочитанная строка будет сохранена:

#include <stdio.h>

int main( int argc, char **argv )
{
    char line[ 1024 ];

    FILE *f = fopen( argv[ 1 ], "r" );
    if ( NULL == f )
    {
        return( 1 );
    }

    for ( ;; )
    {
        char *p = fgets( line, sizeof( line ), f );
        if ( NULL == p )
        {
            break;
        }
    }

    printf( "last line: %s\n", line );

    return( 0 ); 
}

Это зависит от требуемого поведения fgets():

Функция fgets возвращает s в случае успеха. Если обнаружен конец файла и в массив не были прочитаны символы, содержимое массива остается неизменным и возвращается нулевой указатель.

Надежный код должен проверять наличие ошибок с помощью ferror().

Внедрение этого в обработку текста остается в качестве упражнения... ;-)