Given a text file. It is necessary to rewrite its lines to another file. Si

An option that does not require downloading the source file to memory.

The idea is that in fact we can move (see fseek ) before writing to the file in any place and write the next line there. Therefore, we will write the lines in the output file back to front, moving from its end to the beginning.

Let's measure the size of the source file. Let's read the first line of it. Step back in the output file from the size of the input file for the length of the read line and write it down. Then we repeat, stepping back from the position of the beginning of the last displayed line.

However, better look at the code itself -)

 #include <stdio.h> #include <stdlib.h> int main (int argc, char const *argv[]) { if ( 3 != argc ) { fprintf(stderr, "Usage: ./a.out in-file out-reverse-file\n"); return -1; } FILE *fp_in = fopen( argv[1], "r" ); if ( NULL == fp_in ) return -2; FILE *fp_out = fopen(argv[2], "w"); if ( NULL == fp_out ) return -2; if ( fseek( fp_in, 0, SEEK_END ) ) return -3; long int outpos = ftell( fp_in ); /*теперь в outpos находится размер файла*/ if ( fseek( fp_in, 0, SEEK_SET ) ) return -3; /*здесь будет размер прочитанной строчки*/ ssize_t line_size; /*сюда будет записываться сама строка*/ char* line = NULL; /*здесь будет размер для line, динамически выделенной функцией getline (потому что line у нас NULL)*/ size_t strcap; while ( ( line_size = getline( &line, &strcap, fp_in ) ) > 0) { outpos -= line_size; if ( fseek( fp_out, outpos, SEEK_SET ) != 0 || fputs( line, fp_out ) == EOF ) return -4; } /*не забываем освободить память, динамически выделенной функцией getline*/ free(line); return 0; } 

If your system does not have getline , then writing it will be in any sense a useful exercise.

 #include <stdio.h> #include <stdlib.h> #include <assert.h> #include <string.h> int main(int argc, char **argv) { if (argc != 3) { fprintf(stderr, "Usage: %s <file in> <file out>\n", argv[0]); return 1; } FILE *fin, *fout; if ((fin = fopen(argv[1], "r")) == NULL) { perror(argv[1]); return 2; } if ((fout = fopen(argv[2], "w")) == NULL) { fclose(fin); perror(argv[2]); return 3; } size_t lines = 0; while (!feof(fin)) { int k = fgetc(fin); if (k == '\n') lines++; } char buffer[256]; char **a = malloc(sizeof(char *) * lines); assert(a); fseek(fin, 0L, SEEK_SET); size_t i = 0; while (!feof(fin)) { if (fgets(buffer, sizeof(buffer), fin) != NULL) { size_t len = strlen(buffer); a[i] = malloc(len + 1); assert(a[i]); memcpy(a[i], buffer, len + 1); i++; } } for (long i = lines - 1; i >= 0; i--) { fprintf(fout, "%s", a[i]); free(a[i]); } free(a); fclose(fin); fclose(fout); return 0; } 

Prologue:

At @avp, the solution is much better, but if for some reason you need some more complicated mediation with the text, writing them, for example, in char** , you can see my solution.

There are no functions, all in one, so you can not figure it out.

Let's just write it on the ANSI standard :)

A few notes:

• few comments, because it would be redundant: D;
• I tried to validate everything carefully, so the code seems large;
• preprocessor directives - at the end.

main itself:

 /*gcc -o main ...*/ /*./main input_file output_file*/ int main(int argc, char const *argv[]) { if ( 3 != argc ) return -1; if ( 0 != write_reverse_from( argv[1], argv[2] ) ) { fprintf(stderr,"Writing has been failed!\n"); return -2; } return 0; } 

All the most interesting is in write_reverse_from (tried to write as much as possible, in my understanding, "pure", so that you could understand):

 int write_reverse_from ( const char* file_in_name, const char* file_out_name ) { FILE* fp_input; FILE* fp_output; char** input_content; uint32_t lines_count; char** output_content; fp_input = fopen( file_in_name, "r" ); fp_output = fopen( file_out_name, "w" ); if ( NULL == fp_input ) return -1; if ( NULL == fp_output ) return -2; /*получить количество строк в файле*/ lines_count = get_lines_count_from( fp_input ); if ( 0 == lines_count ) return -3; /*получить контент в виде массива строк*/ input_content = get_input_content( fp_input, lines_count ); /*закрываем файловый поток исходного файла. Больше не нужен*/ fclose( fp_input ); if ( NULL == input_content ) { fclose( fp_output ); return -4; } /*получить "перевёрнутый" массив строк*/ output_content = get_reversed_content_from( input_content, lines_count ); if ( NULL == output_content ) { free_content( input_content, lines_count ); fclose( fp_output ); return -5; } /*записать результат в итоговый файл*/ print_content_to( fp_output, output_content, lines_count ); /*динамическое освобождение памяти content-ов*/ free_content( input_content, lines_count ); free_content( output_content, lines_count ); fclose( fp_output ); return 0; } 

I am showing now the implementation in order.

The function get_lines_count_from just "goes over" in a standard way (not feof way, please note: D) through the file, "winding" a simple counter:

 static uint32_t get_lines_count_from ( FILE* opened_fp ) { uint32_t lines_count = 0L; char line[ MAX_LINE_SIZE ]; if ( NULL == opened_fp ) return 0; fseek( opened_fp, 0L, SEEK_SET ); /* решения с feof лучше не использовать */ while ( NULL != fgets( line, MAX_LINE_SIZE, opened_fp ) ) lines_count++; return lines_count; } 

Here is how I take the contents of the input file:

 static char** get_input_content ( FILE* opened_fp, uint32_t lines_count ) { char line[ MAX_LINE_SIZE ] = {0}; char** content; uint32_t alloc_counter = 0L; if ( NULL == opened_fp || 0L == lines_count ) return NULL; content = malloc( sizeof( char** ) * lines_count ); while( alloc_counter < lines_count ) { content[alloc_counter] = malloc( sizeof(char*) * MAX_LINE_SIZE ); alloc_counter++; } alloc_counter = 0L; fseek( opened_fp, 0L, SEEK_SET ); while( NULL != fgets( line, MAX_LINE_SIZE, opened_fp ) ) { strcpy( content[alloc_counter], line ); memset( line, 0, MAX_LINE_SIZE); alloc_counter++; } return content; } 

Here it is "turning":

 static char** get_reversed_content_from( char** content, uint32_t lines_count ) { uint32_t alloc_counter = 0L; char* last_content_line; char** reversed_content; if ( NULL == content || 0L == lines_count ) return NULL; last_content_line = content[ lines_count - 1UL ]; if ( NULL == strchr( last_content_line, '\n' ) ) /*если в последней строке нет символа новой строки*/ { if ( MAX_LINE_SIZE - 1UL <= strlen( last_content_line ) ) return NULL; strcat( last_content_line, LINE_END ); /*символ NUL после этого добавлять не обязательно, потому что при чтении у нас ифнормация заносилась в заранее инициализированный нулями массив, и только потом было перемещение в динамическую память (найдите строчку с memset)*/ } reversed_content = malloc( sizeof( char** ) * lines_count ); while( alloc_counter < lines_count ) { reversed_content[alloc_counter] = malloc( sizeof(char*) * MAX_LINE_SIZE ); strcpy(reversed_content[alloc_counter], content[lines_count - 1U - alloc_counter]); alloc_counter++; } return reversed_content; } 

Output to the final file:

 static int print_content_to( FILE* opened_fp, char** content, uint32_t lines_count) { uint32_t lines_counter = 0; if ( NULL == opened_fp || NULL == content || 0L == lines_count ) return -1; while( lines_counter < lines_count ) { fprintf(opened_fp, "%s", content[lines_counter]); lines_counter++; } return 0; } 

The very release of variables of type char** :

 static void free_content( char** content, uint32_t lines_count) { uint32_t lines_counter = 0; if ( NULL == content || 0 == lines_count ) return; while ( lines_counter < lines_count ) { free(content[lines_counter]); lines_counter++; } free(content); } 

Well, the promised directives:

 #include <stdio.h> #include <stdlib.h> #include <stdint.h> #include <string.h> #define MAX_LINE_SIZE ( 1024UL ) #ifdef _WIN32 #define LINE_END "\r\n" #else #define LINE_END "\n" #endif