Скопировать содержимое, ограничив длину строки N символами - C (СИ)

Узнай цену своей работы

Формулировка задачи:

Всем доброго времени суток, нужна помощь с задачей: "Скопировать содержимое текстового файла, ограничив длину строки N символами. Слова, не помещающиеся в заданную строку не копировать." Поработав с программами, найденными в интернете получил две разные программы: 1)
Листинг программы 
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4.  
  5. #define LEN_STR  1024
  6. #define N        5
  7.  
  8. char  seps[10] = " ,.!?:;'\n";
  9. char* text;
  10. char* temp;
  11. FILE* source;
  12. FILE* target;
  13.  
  14. void main(void)
  15. {
  16.     source = fopen("1.txt", "rt");
  17.     target = fopen("2.txt", "wt");
  18.     text   = (char*)calloc(LEN_STR, 1);
  19.     temp   = (char*)calloc(LEN_STR, 1);
  20.  
  21.     while (!feof(source))
  22.     {
  23.         fgets(text, LEN_STR, source);
  24.         strncpy(temp, text, N);
  25.         if (strlen(text) > N)
  26.         {
  27.             temp[N] = '\n';
  28.             temp[N + 1] = 0;
  29.         }
  30.         fputs(temp, target);
  31.     }
  32.  
  33.     fclose(source);
  34.     fclose(target);
  35.     free(text);
  36.     free(temp);
  37. }
2)
Листинг программы 
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  4.  
  5. #define MAXLEN 4        //Макс. длина строки
  6.  
  7. int main(void)
  8. {
  9.     char c=0;    //Хранится символ из входного файла, вспомогательная переменная
  10.     char String[MAXLEN + 1];
  11.  
  12.     char *pathFileInput=(char*)calloc(20, sizeof(char));
  13.     char *pathFileOutput=(char*)calloc(20, sizeof(char));
  14.     FILE *fileInput;    //Файловая переменная для входного файла
  15.     FILE *fileOutput;    //Файловая переменная для выходного файла
  16.  
  17.     fileInput=fopen("1.txt",  "rt");
  18.     fileOutput= fopen("2.txt", "wt");
  19.     while(c!=EOF)
  20.     {
  21.         fgets(String,MAXLEN + 1,fileInput);
  22.         fputs(String,fileOutput);
  23.         fputc('\n', fileOutput);
  24.         while (c != '\n' && c != EOF)
  25.             c = fgetc(fileInput);
  26.  
  27.         if (c!=EOF) //Если это не признак конца файла, c = пробел (или любой другой неслужебный символ
  28.             c=' '; //иначе мы застрянем во вложенном while на след. итерации
  29.     }
  30.  
  31.     free(pathFileInput);
  32.     free(pathFileOutput);
  33.     fclose (fileInput);
  34.     fclose(fileOutput);
  35.     return 0;
  36. }
И всё бы ничего, но обе программы просто обрывают слова на середине, если эти слова не влезают в длину, а нужно, чтобы если слово не помещалось, то оно целиком и полностью удалялось. Посидев, пораскинув мозгами прикинул следующую схему: 1) Копируем текстовый документ 1.txt, работаем с каждой строкой по очереди; 2) В общем цикле для работы с каждой строкой: Разбивать строку на слова, слова заносить в массив, а дальше в цикле сравнивать длину i первых слов в массиве (с пробелами) с числом N. Если i < N, то идти дальше. Если i > N, то если кол-во слов больше одного, то записывать [i-1] слов из массива в строку и переходить к следующей строке. Ну или как-то так. На словах, как говорится, Лев Толстой... А время поджимает. Попробовав реализовать, понял, что проблема в моих знаниях и опыте. Буду очень благодарен, если доделаете мою программу или предложите свой вариант. Мои наработки:
Листинг программы 
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4.  
  5. #define LEN_STR  1024
  6. #define N        5
  7.  
  8. char  seps[10] = " ,.!?:;'\n";
  9. char* text;
  10. char* temp;
  11. char* word;
  12.  
  13. FILE* source;
  14. FILE* target;
  15.  
  16. char* data[100];
  17.  
  18. void main(void)
  19. {
  20.     source = fopen("1.txt", "rt");
  21.     target = fopen("2.txt", "wt");
  22.     text   = (char*)calloc(LEN_STR, 1);
  23.     temp   = (char*)calloc(LEN_STR, 1);
  24.  
  25.     while (!feof(source))
  26.     {
  27.         fgets(text, LEN_STR, source);
  28.  
  29.         //Заимствуем код из программы, удаляющей слова, больше определённого размера
  30.         //last = temp;
  31.         //word = strtok(temp, seps);
  32.         //while (word)
  33.         //{
  34.         //    strncat(res, text + (last - temp), word - last);
  35.         //    if (strlen(word) <= N)
  36.         //        strcat(res, word);
  37.         //
  38.         //    last = word + strlen(word);
  39.         //    word = strtok(NULL, seps);
  40.         //}
  41.         //strcat(res, text + (last - temp));
  42.  
  43.         word = strtok(temp, seps);
  44.         while (word)
  45.         {
  46.                         data = data + word;
  47.                     if (strlen(data) > N)
  48.                 {
  49.                   temp[N] = '\n';
  50.                   temp[N + 1] = 0;
  51.                 }
  52.                 fputs(temp, target);
  53.                         word = strtok(NULL, seps);
  54.         }
  55.         strcat(res, text + (last - temp));
  56.     }
  57.  
  58.     fclose(source);
  59.     fclose(target);
  60.     free(text);
  61.     free(temp);
  62. }

Решение задачи: «Скопировать содержимое, ограничив длину строки N символами»

textual
Листинг программы 
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <ctype.h>
  4. #include <stdlib.h>
  5.  
  6. #define DEFAULT_OUTPUT_WIDTH (80)
  7. #define PROGRAM_NAME argv[0]
  8. #define INPUT_FILE_NAME argv[1]
  9. #define OUTPUT_FILE_NAME argv[2]
  10. #define OUTPUT_WIDTH argv[3]
  11. #define INPUT_BUFFER_SIZE (2048)
  12.  
  13. int main(int argc, char ** argv) {
  14.     FILE * fIn, * fOut;
  15.     char * bufIn, * bufOut, * posPtr;
  16.     size_t inpLen, outLen, tmpLen;
  17.     
  18.     if ( argc < 2 ) {
  19.         fprintf(stderr, "USAGE: %s input_file [output_file [width]]\n", PROGRAM_NAME);
  20.         exit(EXIT_FAILURE);
  21.     }
  22.     
  23.     if ( argc == 4 ) {
  24.         outLen = atoi(OUTPUT_WIDTH);
  25.         if ( outLen < 1 || outLen >= INPUT_BUFFER_SIZE ) {
  26.             fprintf(stderr, "%s: wrong parameter to output width - %lu\n", PROGRAM_NAME, outLen);
  27.             exit(EXIT_FAILURE);
  28.         }
  29.     }
  30.     else
  31.         outLen = DEFAULT_OUTPUT_WIDTH;
  32.     
  33.     if ( ! ( bufIn = malloc(INPUT_BUFFER_SIZE) ) ) {
  34.         perror("malloc");
  35.         exit(EXIT_FAILURE);
  36.     }
  37.     
  38.     if ( ! ( bufOut = malloc(outLen + 2) ) ) {
  39.         free(bufIn);
  40.         perror("malloc");
  41.         exit(EXIT_FAILURE);
  42.     }
  43.     
  44.     if ( ! ( fIn = fopen(INPUT_FILE_NAME, "r") ) ) {
  45.         fprintf(stderr, "%s: can't open file %s for input!\n", PROGRAM_NAME, INPUT_FILE_NAME);
  46.         free(bufIn);
  47.         free(bufOut);
  48.         exit(EXIT_FAILURE);
  49.     }
  50.     
  51.     if ( argc == 2 )
  52.         fOut = stdout;
  53.     else {
  54.         if ( ! ( fOut = fopen(OUTPUT_FILE_NAME, "w") ) ) {
  55.             fprintf(stderr, "%s: can't open file %s for output!\n", PROGRAM_NAME, OUTPUT_FILE_NAME);
  56.             fclose(fIn);
  57.             free(bufIn);
  58.             free(bufOut);
  59.             exit(EXIT_FAILURE);
  60.         }
  61.     }
  62.     
  63.     while ( fgets(bufIn, INPUT_BUFFER_SIZE, fIn) ) {
  64.         while ( ( inpLen = strlen(bufIn) ) > outLen ) {
  65.             for ( posPtr = bufIn + outLen - 1; posPtr >= bufIn && ! isspace(*posPtr); --posPtr )
  66.                 ;
  67.             if ( posPtr < bufIn ) {
  68.                 memcpy(bufOut, bufIn, outLen);
  69.                 bufOut[outLen] = '\n';
  70.                 bufOut[outLen + 1] = '\0';
  71.                 if ( fprintf(fOut, "%s", bufOut) == EOF ) {
  72.                     fprintf(stderr, "%s: can't write to output file!\n", PROGRAM_NAME);
  73.                     if ( fclose(fIn) )
  74.                         perror("While close input file");
  75.                     if ( fclose(fOut) )
  76.                         perror("While close output file");
  77.                     free(bufIn);
  78.                     free(bufOut);
  79.                     exit(EXIT_FAILURE);
  80.                 }
  81.                 memmove(bufIn, bufIn + outLen, strlen(bufIn + outLen) + 1);
  82.             }
  83.             else {
  84.                 tmpLen = posPtr - bufIn;
  85.                 memcpy(bufOut, bufIn, tmpLen);
  86.                 bufOut[tmpLen] = '\n';
  87.                 bufOut[tmpLen + 1] = '\0';
  88.                 if ( fprintf(fOut, "%s", bufOut) == EOF ) {
  89.                     fprintf(stderr, "%s: can't write to output file!\n", PROGRAM_NAME);
  90.                     if ( fclose(fIn) )
  91.                         perror("While close input file");
  92.                     if ( fclose(fOut) )
  93.                         perror("While close output file");
  94.                     free(bufIn);
  95.                     free(bufOut);
  96.                     exit(EXIT_FAILURE);
  97.                 }
  98.                 memmove(bufIn, bufIn + tmpLen + 1, strlen(bufIn + tmpLen));
  99.             }
  100.         }
  101.         if ( inpLen ) {
  102.             if ( fprintf(fOut, "%s", bufIn) == EOF ) {
  103.                 fprintf(stderr, "%s: can't write to output file!\n", PROGRAM_NAME);
  104.                 if ( fclose(fIn) )
  105.                     perror("While close input file");
  106.                 if ( fclose(fOut) )
  107.                     perror("While close output file");
  108.                 free(bufIn);
  109.                 free(bufOut);
  110.                 exit(EXIT_FAILURE);
  111.             }
  112.         }
  113.     }
  114.     
  115.     if ( ferror(fIn) ) {
  116.         fprintf(stderr, "%s: error while reading input file!\n", PROGRAM_NAME);
  117.         if ( fclose(fIn) )
  118.             perror("While close input file");
  119.         if ( fclose(fOut) )
  120.             perror("While close output file");
  121.         free(bufIn);
  122.         free(bufOut);
  123.         exit(EXIT_FAILURE);
  124.     }
  125.     
  126.     if ( fclose(fIn) )
  127.         perror("While close input file");
  128.     if ( fOut != stdout && fclose(fOut) )
  129.         perror("While close output file");
  130.     
  131.     free(bufIn);
  132.     free(bufOut);
  133.     
  134.     exit(EXIT_SUCCESS);
  135. }

Объяснение кода листинга программы

Этот код предназначен для копирования содержимого из одного файла в другой с ограничением на количество символов в каждой строке. Он использует стандартные библиотеки C и может быть скомпилирован с помощью любого компилятора C. Список переменных и их значений:

  1. argc - количество аргументов в командной строке (обычно 2 или 4)
  2. argv - массив строк, содержащих параметры командной строки
  3. PROGRAM_NAME - имя программы (обычно имя исполняемого файла)
  4. INPUT_FILE_NAME - имя входного файла
  5. OUTPUT_FILE_NAME - имя выходного файла (если не указано, то это stdout)
  6. OUTPUT_WIDTH - ширина вывода (если не указано, то это 80)
  7. DEFAULT_OUTPUT_WIDTH - значение по умолчанию для OUTPUT_WIDTH, равное 80
  8. INPUT_BUFFER_SIZE - размер буфера ввода, равный 2048
  9. fIn - файловый указатель на входной файл
  10. fOut - файловый указатель на выходной файл (может быть stdout)
  11. bufIn - указатель на буфер ввода
  12. bufOut - указатель на буфер вывода
  13. inpLen - длина строки в буфере ввода
  14. outLen - длина строки в буфере вывода
  15. tmpLen - временная переменная для хранения длины строки
  16. posPtr - указатель на текущую позицию в строке
  17. isspace - функция, проверяющая, является ли символ пробелом
  18. fprintf - функция, используемая для записи в файл вывода
  19. fclose - функция, используемая для закрытия файла
  20. perror - функция, используемая для вывода сообщения об ошибке Основной цикл программы считывает строки из входного файла и записывает их в выходной файл, обрезая строки до заданной ширины. Если входной файл содержит символы новой строки ('\n'), они сохраняются в выходном файле. Если выходной файл не stdout, он закрывается после записи всех строк.

ИИ поможет Вам:

  • решить любую задачу по программированию
  • объяснить код
  • расставить комментарии в коде
  • и т.д
Попробуйте бесплатно

Оцени полезность:

8   голосов , оценка 4.25 из 5

Нужна аналогичная работа?

Оформи быстрый заказ и узнай стоимость

Бесплатно
Оформите заказ и авторы начнут откликаться уже через 10 минут
Похожие ответы