ПЗ3.Программирование. Кагарлык. Лабораторная работа 7 Работа с текстовыми файлами Часть Работа с текстовыми файлами Пример #include Кагарлык Евгения

• Название: Лабораторная работа 7 Работа с текстовыми файлами Часть Работа с текстовыми файлами Пример #include Кагарлык Евгения
• Дата: 10.10.2022
• Размер: 1.86 Mb.
• Имя файла: ПЗ3.Программирование. Кагарлык.docx
• Тип: Лабораторная работа; #726272

Российский государственный социальный университет

ПРАКТИЧЕСКОЕ ЗАДАНИЕ 3

по дисциплине «Программирование»

ФИО студента	Кагарлык Евгения Васильевна
Направление подготовки	Информационные системы и технологии
Группа	ИСТ-Б-01-Д-2020-1

Москва

Лабораторная работа № 7

Работа с текстовыми файлами

Часть 1. Работа с текстовыми файлами

Пример 1.

#include //Кагарлык Евгения

#include

#include

void main() {

    //С помощью переменной file будем осуществлять доступ к файлу

    FILE *file;

    //Открываем текстовый файл с правами на запись

    file = fopen("C:/c/test.txt", "w+t");

    //Пишем в файл

    fprintf(file, "Hello, World!");

    //Закрываем файл

    fclose(file);

    getch();

}

Параметры доступа к файлу.

Пример 2

#include //Кагарлык Евгения

#include

#include

void main() {

FILE *file;

char buffer[128];

file = fopen("C:/c/test.txt", "w");

fprintf(file, "Hello, World!");

fclose(file);

file = fopen("C:/c/test.txt", "r");

fgets(buffer, 127, file);

printf("%s", buffer);

fclose(file);

getch();

}

Пример 3

#include //Кагарлык Евгения

#include

#include

void main() {

int a, b;

fprintf(stdout, "Enter two numbers\n");

fscanf(stdin, "%d", &a);

fscanf(stdin, "%d", &b);

if (b == 0) {

fprintf(stderr, "Error: divide by zero");

} else {

fprintf(stdout, "%.3f", (float) a / (float) b);

}

getch();

}

Ошибка открытия файла

Пример 4

#include //Кагарлык Евгения

#include

#include

#define ERROR_OPEN_FILE -3

void main() {

FILE *file;

char buffer[128];

file = fopen("C:/c/test.txt", "w");

if (file == NULL) {

printf("Error opening file");

getch();

exit(ERROR_OPEN_FILE);

}

fprintf(file, "Hello, World!");

freopen("C:/c/test.txt", "r", file);

if (file == NULL) {

printf("Error opening file");

getch();

exit(ERROR_OPEN_FILE);

}

fgets(buffer, 127, file);

printf("%s", buffer);

fclose(file);

getch();

}

Пример 5

#include //Кагарлык Евгения

#include

#include

#define ERROR_OPEN_FILE -3

void main() {

FILE *inputFile, *outputFile;

unsigned m, n;

unsigned i, j;

inputFile = fopen(INPUT_FILE, READ_ONLY);

if (inputFile == NULL) {

printf("Error opening file %s", INPUT_FILE);

getch();

exit(3);

}

outputFile = fopen(OUTPUT_FILE, WRITE_ONLY);

if (outputFile == NULL) {

printf("Error opening file %s", OUTPUT_FILE);

getch();

if (inputFile != NULL) {

fclose(inputFile);

}

exit(4);

}

fgets(buffer, 127, file);

printf("%s", buffer);

fclose(file);

getch();

}

Буферизация данных

Пример 6

#include //Кагарлык Евгения

#include

#include

void main() {

FILE *file;

char c;

file = fopen("C:/c/test.txt", "w");

do {

c = getch();

fprintf(file, "%c", c);

fprintf(stdout, "%c", c);

//fflush(file);

} while(c != 'q');

fclose(file);

getch();

}

Часть 2. Примеры

Пример 1

В одном файле записаны два числа - размерности массива. Заполним второй файл массивом случайных чисел.

#define _CRT_SECURE_NO_WARNINGS//Кагарлык Евгения Васильевна

#include

#include

#include

#include

#define INPUT_FILE "D:/c/input.txt"

#define OUTPUT_FILE "D:/c/output.txt"

#define READ_ONLY "r"

#define WRITE_ONLY "w"

#define MAX_DIMENSOIN 3

#define ERROR_OPEN_FILE -3

void main()

{

FILE* inputFile, * outputFile;

unsigned m, n;

unsigned i, j;

inputFile = fopen(INPUT_FILE, READ_ONLY);

if (inputFile == NULL)

{

printf("Ошбка открытия файла %s", INPUT_FILE);

_getch();

exit(ERROR_OPEN_FILE);

}

outputFile= fopen(OUTPUT_FILE, WRITE_ONLY);

if (outputFile==NULL)

{

printf("Ошбка открытия файла %s", OUTPUT_FILE);

_getch();

if (inputFile != NULL)

{

fclose(inputFile);

}

exit(ERROR_OPEN_FILE);

}

fscanf(inputFile, "%ud %ud", &m, &n);

if (m>MAX_DIMENSOIN)

{

m=MAX_DIMENSOIN;

}

if (n>MAX_DIMENSOIN)

{

n=MAX_DIMENSOIN;

}

srand(time(NULL));

for (i=0; i
{

for (j=0; j
{

fprintf(outputFile, "\n");

}

fclose(inputFile);

fclose(outputFile);

}

}

Пример 2

#define _CRT_SECURE_NO_WARNINGS

#include //Кагарлык Евгения

#include

#include

#define ERROR_FILE_OPEN -3

void main() {

FILE *origin = NULL;

FILE *output = NULL;

char filename[1024];

int mode;

printf("Enter filename: ");

scanf("%1023s", filename);

origin = fopen(filename, "r");

if (origin == NULL) {

printf("Error opening file %s", filename);

getch();

exit(ERROR_FILE_OPEN);

}

printf("enter mode: [1 - copy, 2 - print] ");

scanf("%d", &mode);

if (mode == 1) {

printf("Enter filename: ");

scanf("%1023s", filename);

output = fopen(filename, "w");

if (output == NULL) {

printf("Error opening file %s", filename);

getch();

fclose(origin);

exit(ERROR_FILE_OPEN);

}

} else {

output = stdout;

}

while (!feof(origin)) {

fprintf(output, "%c", fgetc(origin));

}

fclose(origin);

fclose(output);

getch();

}

Пример 3

#include //Кагарлык Евгения

#include

#include

#define ERROR_FILE_OPEN -3

void main() {

FILE *output = NULL;

char c;

output = fopen("D:/c/test_output.txt", "w+t");

if (output == NULL) {

printf("Error opening file");

_getch();

exit(ERROR_FILE_OPEN);

}

for (;;) {

c = _getch();

if (c == 27) {

break;

}

fputc(c, output);

fputc(c, stdout);

}

fclose(output);

}

Пример 4

#define _CRT_SECURE_NO_WARNINGS//Кагарлык Евгения Васильевна

#include

#include

#include

#include

#define ERROR_FILE_OPEN -3

void main() {

FILE *input = NULL;

int num, maxn, hasRead;

input = fopen("D:/c/input.txt", "r");

if (input == NULL) {

printf("Error opening file");

_getch();

exit(ERROR_FILE_OPEN);

}

maxn = INT_MIN;

hasRead = 1;

while (hasRead == 1){

hasRead = fscanf(input, "%d", &num);

if (hasRead != 1){

continue;

}

if (num > maxn) {

maxn = num;

}

}

printf("max number = %d", maxn);

fclose(input);

_getch();

}

Пример 5

#include //Кагарлык Евгения

#include

#include

#include

#define ERROR_FILE_OPEN -3

void main() {

FILE *input = NULL;

char buffer[512];

char enWord[128];

char ruWord[128];

char usrWord[128];

unsigned index;

int length;

int wasFound;

input = fopen("D:/c/input.txt", "r");

if (input == NULL) {

printf("Error opening file");

_getch();

exit(ERROR_FILE_OPEN);

}

printf("enter word: ");

fgets(usrWord, 127, stdin);

wasFound = 0;

while (!feof(input)) {

fgets(buffer, 511, input);

length = strlen(buffer);

for (index = 0; index < length; index++) {

if (buffer[index] == '\t') {

buffer[index] = '\0';

break;

}

}

strcpy(ruWord, buffer);

strcpy(enWord, &buffer[index + 1]);

if (!strcmp(enWord, usrWord)) {

wasFound = 1;

break;

}

}

if (wasFound) {

printf("%s", ruWord);

} else {

printf("Word not found");

}

fclose(input);

_getch();

}

Пример 6

#define _CRT_SECURE_NO_WARNINGS

#include //Кагарлык Евгения

#include

#include

int cntLines(const char *filename) {

int lines = 0;

int any; //any типа int, потому что EOF имеет тип int!

FILE *f = fopen(filename, "r");

if (f == NULL) {

return -1;

}

do {

any = fgetc(f);

//printf("%c", any);//debug

if (any == '\n') {

lines++;

}

} while(any != EOF);

fclose(f);

return lines;

}

void main() {

printf("%d\n", cntLines("C:/c/file.txt"));

_getch();

}





Лабораторная работа № 8

Работа с бинарными файлами

Часть 1. Бинарные файлы

Пример 1

#include //Кагарлык Евгения

#include

#include

#define ERROR_FILE_OPEN -3

void main() {

FILE *output = NULL;

int number;

output = fopen("D:/c/output.bin", "wb");

if (output == NULL) {

printf("Error opening file");

getch();

exit(ERROR_FILE_OPEN);

}

scanf("%d", &number);

fwrite(&number, sizeof(int), 1, output);

fclose(output);

_getch();

}

Пример 2

#include //Кагарлык Евгения

#include

#include

#define ERROR_FILE_OPEN -3

void main() {

FILE *input = NULL;

int number;

input = fopen("D:/c/output.bin", "rb");

if (input == NULL) {

printf("Error opening file");

getch();

exit(ERROR_FILE_OPEN);

}

fread(&number, sizeof(int), 1, input);

printf("%d", number);

fclose(input);

_getch();

}

Пример 3

#include //Кагарлык Евгения

#include

#include

#define ERROR_FILE_OPEN -3

void main() {

FILE *iofile = NULL;

int number;

iofile = fopen("D:/c/output.bin", "w+b");

if (iofile == NULL) {

printf("Error opening file");

getch();

exit(ERROR_FILE_OPEN);

}

scanf("%d", &number);

fwrite(&number, sizeof(int), 1, iofile);

fseek(iofile, 0, SEEK_SET);

number = 0;

fread(&number, sizeof(int), 1, iofile);

printf("%d", number);

fclose(iofile);

_getch();

}

Пример 4

#include //Кагарлык Евгения

#include

#include

#define ERROR_OPEN_FILE -3

void main() {

FILE *iofile = NULL;

unsigned counter = 0;

int num;

int yn;

iofile = fopen("D:/c/numbers.bin", "w+b");

if (iofile == NULL) {

printf("Error opening file");

getch();

exit(ERROR_OPEN_FILE);

}

fwrite(&counter, sizeof(int), 1, iofile);

do {

printf("enter new number? [1 - yes, 2 - no]");

scanf("%d", &yn);

if (yn == 1) {

scanf("%d", &num);

fwrite(&num, sizeof(int), 1, iofile);

counter++;

} else {

rewind(iofile);

fwrite(&counter, sizeof(int), 1, iofile);

break;

}

} while(1);

fclose(iofile);

getch();

}

Часть 2. Примеры

Пример 1

#include //Кагарлык Евгения

#include

#include

#define SIZE 10

void main() {

const char filename[] = "D:/c/state";

FILE *bfile = NULL;

int pos;

int value = 0;

int i;

char wasCreated;

do {

wasCreated = 0;

bfile = fopen(filename, "r+b");

if (NULL == bfile) {

printf("Try to create file...\n");

getch();

bfile = fopen(filename, "wb");

if (bfile == NULL) {

printf("Error when create file");

getch();

exit(1);

}

for (i = 0; i < SIZE; i++) {

fwrite(&value, sizeof(int), 1, bfile);

}

printf("File created successfully...\n");

fclose(bfile);

wasCreated = 1;

}

} while(wasCreated);

do {

printf("Enter position [0..9] ");

scanf("%d", &pos);

if (pos < 0 || pos >= SIZE) {

break;

}

printf("Enter value ");

scanf("%d", &value);

fseek(bfile, pos*sizeof(int), SEEK_SET);

fwrite(&value, sizeof(int), 1, bfile);

rewind(bfile);

for (i = 0; i < SIZE; i++) {

fread(&value, sizeof(int), 1, bfile);

printf("%d ", value);

}

printf("\n");

} while(1);

fclose(bfile);

}

Пример 2

#include //Кагарлык Евгения

#include

#include

#include

#define ERROR_FILE_OPEN -3

void main() {

const char filename[] = "C:/c/words.bin";

const char termWord[] = "exit";

char buffer[128];

unsigned int len;

FILE *wordsFile = NULL;

printf("Opening file...\n");

wordsFile = fopen(filename, "w+b");

if (wordsFile == NULL) {

printf("Error opening file");

getch();

exit(ERROR_FILE_OPEN);

}

printf("Enter words\n");

do {

scanf("%127s", buffer);

if (strcmp(buffer, termWord) == 0) {

len = 0;

fwrite(&len, sizeof(unsigned), 1, wordsFile);

break;

}

len = strlen(buffer);

fwrite(&len, sizeof(unsigned), 1, wordsFile);

fwrite(buffer, 1, len, wordsFile);

} while(1);

printf("rewind and read words\n");

rewind(wordsFile);

getch();

do {

fread(&len, sizeof(int), 1, wordsFile);

if (len == 0) {

break;

}

fread(buffer, 1, len, wordsFile);

buffer[len] = '\0';

printf("%s\n", buffer);

} while(1);

fclose(wordsFile);

getch();

}

Пример 3

#include //Кагарлык Евгения

#include

#include

#define DEBUG

#ifdef DEBUG

#define debug(data) printf("%s", data);

#else

#define debug(data)

#endif

const char inputFile[] = "D:/c/xinput.txt";

const char outputFile[] = "D:/c/output.bin";

struct someArgs {

int* items;

size_t number;

};

int writeToFile(FILE *file, void* args) {

size_t i;

struct someArgs *data = (struct someArgs*) args;

debug("write to file\n")

fwrite(data->items, sizeof(int), data->number, file);

debug("write finished\n")

return 0;

}

int readAndCallback(FILE *file, void* args) {

struct someArgs data;

size_t size, i = 0;

int result;

debug("read from file\n")

fscanf(file, "%d", &size);

data.items = (int*) malloc(size*sizeof(int));

data.number = size;

while (!feof(file)) {

fscanf(file, "%d", &data.items[i]);

i++;

}

debug("call withOpenFile\n")

result = withOpenFile(outputFile, "w", writeToFile, &data);

debug("read finish\n")

free(data.items);

return result;

}

int doStuff() {

return withOpenFile(inputFile, "r", readAndCallback, NULL);

}

//Обёртка - функция открывает файл. Если файл был благополучно открыт,

//то вызывается функция fun. Так как аргументы могут быть самые разные,

//то они передаются через указатель void*. В качестве типа аргумента

//разумно использовать структуру

int withOpenFile(const char *filename,

const char *mode,

int (*fun)(FILE* source, void* args),

void* args) {

FILE *file = fopen(filename, mode);

int err;

debug("try to open file ")

debug(filename)

debug("\n")

if (file != NULL) {

err = fun(file, args);

} else {

return 1;

}

debug("close file ")

debug(filename)

debug("\n")

fclose(file);

return err;

}

void main() {

printf("result = %d", doStuff());

getch();

}

Пример 4

#include //Кагарлык Евгения

#include

#include

#include

#define SIZE 100

int saveInt32Array(const char *filename, const int32_t *a, size_t size) {

FILE *out = fopen(filename, "wb");

if (!out) {

return 0;

}

//Записываем длину массива

fwrite(&size, sizeof(size_t), 1, out);

//Записываем весь массив

fwrite(a, sizeof(int32_t), size, out);

fclose(out);

return 1;

}

int loadInt32Array(const char *filename, int32_t **a, size_t *size) {

FILE *in = fopen(filename, "rb");

if (!in) {

return 0;

}

//Считываем длину массива

fread(size, sizeof(size_t), 1, in);

//Инициализируем массив

(*a) = (int32_t*) malloc(sizeof(int32_t) * (*size));

if (!(*a)) {

return 0;

}

//Считываем весь массив

fread((*a), sizeof(int32_t), *size, in);

fclose(in);

return 1;

}

void main() {

const char *tmpFilename = "tmp.bin";

int32_t exOut[SIZE];

int32_t *exIn = NULL;

size_t realSize;

int i;

for (i = 0; i < SIZE; i++) {

exOut[i] = i*i;

}

saveInt32Array(tmpFilename, exOut, SIZE);

loadInt32Array(tmpFilename, &exIn, &realSize);

for (i = 0; i < realSize; i++) {

printf("%d ", exIn[i]);

}

_getch();

}

Пример 5

#define _CRT_SECURE_NO_WARNINGS

#include //Кагарлык Евгения

#include

#include

#include

#include

#define Ok 0

#define ERROR_OPENING_FILE 1

#define ERROR_OUT_OF_MEMORY 2

double mySinus(double x) {

return sin(x);

}

Result tabFunction(const char *filename, double from, double to, double step, double (*f)(double)) {

Result r;

FILE *out = fopen(filename, "wb");

double value;

if (!out) {

r = ERROR_OPENING_FILE;

goto EXIT;

}

fwrite(&from, sizeof(from), 1, out);

fwrite(&to, sizeof(to), 1, out);

fwrite(&step, sizeof(step), 1, out);

for (from; from < to; from += step) {

value = f(from);

fwrite(&value, sizeof(double), 1, out);

}

r = Ok;

EXIT:

fclose(out);

return r;

}

Result loadFunction(const char *filename, double **a, double *from, double *to, double *step) {

Result r;

uintptr_t size;

FILE *in = fopen(filename, "rb");

if (!in) {

r = ERROR_OPENING_FILE;

goto EXIT;

}

fread(from, sizeof(*from), 1, in);

fread(to, sizeof(*to), 1, in);

fread(step, sizeof(*step), 1, in);

size = (uintptr_t) ((*to - *from) / *step);

(*a) = (double*) malloc(sizeof(double)* size);

if (!(*a)) {

r = ERROR_OUT_OF_MEMORY;

goto EXIT;

}

fread((*a), sizeof(double), size, in);

r = Ok;

EXIT:

fclose(in);

return r;

}

void main() {

const char *tmpFilename = "tmp.bin";

Result r;

double *exIn = NULL;

int accuracy, option;

double from, to, step, arg;

uintptr_t index;

printf("Enter parameters\nfrom = ");

scanf("%lf", &from);

printf("to = ");

scanf("%lf", &to);

printf("step = ");

scanf("%lf", &step);

r = tabFunction(tmpFilename, from, to, step, mySinus);

if (r != Ok) {

goto CATCH_SAVE_FUNCTION;

}

accuracy = (int) (-log10(step));

printf("function tabulated from %.*lf to %.*lf with accuracy %.*lf\n",

accuracy, from, accuracy, to, accuracy, step);

r = loadFunction(tmpFilename, &exIn, &from, &to, &step);

if (r != Ok) {

goto CATCH_LOAD_FUNCTION;

}

accuracy = (int)(-log10(step));

do {

printf("1 to enter values, 0 to exit : ");

scanf("%d", &option);

if (option == 0) {

break;

}

else if (option != 1) {

continue;

}

printf("Enter value from %.*lf to %.*lf : ", accuracy, from, accuracy, to);

scanf("%lf", &arg);

if (arg < from || arg > to) {

printf("bad value\n");

continue;

}

index = (uintptr_t) ((arg - from) / step);

printf("saved %.*lf\ncomputed %.*lf\n", accuracy, exIn[index], accuracy, mySinus(arg));

} while (1);

r = Ok;

goto EXIT;

CATCH_SAVE_FUNCTION: {

printf("Error while saving values");

goto EXIT;

}

CATCH_LOAD_FUNCTION: {

printf("Error while loading values");

goto EXIT;

}

EXIT:

free(exIn);

_getch();

exit(r);

}

Пример 6

#define _CRT_SECURE_NO_WARNINGS

#include //Кагарлык Евгения

#include

#include

#include

typedef struct PersonKey {

long long id;

char login[64];

char password[64];

long offset;//Положение соответствующих значений PersonInfo

} PersonKey;

typedef struct PersonInfo {

unsigned age;

char firstName[64];

char lastName[128];

} PersonInfo;

/*

Функция запрашивает у пользователя данные и пишет их подряд в два файла

*/

void createOnePerson(FILE *keys, FILE *values) {

static long long id = 0;

PersonKey pkey;

PersonInfo pinfo;

pkey.id = id++;

//Так как все значения пишутся друг за другом, то текущее положение

//указателя во втором файле будет позицией для новой записи

pkey.offset = ftell(values);

printf("Login: ");

scanf("%63s", pkey.login);

printf("Password: ");

scanf("%63s", pkey.password);

printf("Age: ");

scanf("%d", &(pinfo.age));

printf("First Name: ");

scanf("%63s", pinfo.firstName);

printf("Last Name: ");

scanf("%127s", pinfo.lastName);

fwrite(&pkey, sizeof(pkey), 1, keys);

fwrite(&pinfo, sizeof(pinfo), 1, values);

}

void createPersons(FILE *keys, FILE *values) {

char buffer[2];

int repeat = 1;

int counter = 0;//Количество элементов в файле

//Резервируем место под запись числа элементов

fwrite(&counter, sizeof(counter), 1, keys);

printf("CREATE PERSONS\n");

do {

createOnePerson(keys, values);

printf("\nYet another one? [y/n]");

scanf("%1s", buffer);

counter++;

if (buffer[0] != 'y' && buffer[0] != 'Y') {

repeat = 0;

}

} while(repeat);

//Возвращаемся в начало и пишем количество созданных элементов

rewind(keys);

fwrite(&counter, sizeof(counter), 1, keys);

}

/*

Создаём массив ключей

*/

PersonKey* readKeys(FILE *keys, int *size) {

int i;

PersonKey *out = NULL;

rewind(keys);

fread(size, sizeof(*size), 1, keys);

out = (PersonKey*) malloc(*size * sizeof(PersonKey));

fread(out, sizeof(PersonKey), *size, keys);

return out;

}

/*

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

*/

FILE** openFiles(const char *keysFilename, const char *valuesFilename) {

FILE **files = (FILE**)malloc(sizeof(FILE*)*2);

files[0] = fopen(keysFilename, "w+b");

if (!files[0]) {

return NULL;

}

files[1] = fopen(valuesFilename, "w+b");

if (!files[1]) {

fclose(files[0]);

return NULL;

}

return files;

}

/*

Две вспомогательные функции для вывода ключа и информации

*/

void printKey(PersonKey pk) {

printf("%d. %s [%s]\n", (int)pk.id, pk.login, pk.password);

}

void printInfo(PersonInfo info) {

printf("%d %s %s\n", info.age, info.firstName, info.lastName);

}

/*

Функция по ключу (вернее, по его полю offset)

достаёт нужное значение из второго файла

*/

PersonInfo readInfoByPersonKey(PersonKey pk, FILE *values) {

PersonInfo out;

rewind(values);

fseek(values, pk.offset, SEEK_SET);

fread(&out, sizeof(PersonInfo), 1, values);

return out;

}

void getPersonsInfo(PersonKey *keys, FILE *values, int size) {

int index;

PersonInfo p;

do {

printf("Enter position of element. To exit print bad index: ");

scanf("%d", &index);

if (index < 0 || index >= size) {

printf("Bad index");

return;

}

p = readInfoByPersonKey(keys[index], values);

printInfo(p);

} while (1);

}

void main() {

int size;

int i;

PersonKey *keys = NULL;

FILE **files = openFiles("C:/c/keys.bin", "C:/c/values.bin");

if (files == 0) {

printf("Error opening files");

goto FREE;

}

createPersons(files[0], files[1]);

keys = readKeys(files[0], &size);

for (i = 0; i < size; i++) {

printKey(keys[i]);

}

getPersonsInfo(keys, files[1], size);

fclose(files[0]);

fclose(files[1]);

FREE:

free(files);

free(keys);

_getch();

}





Лабораторная работа № 9

Задания на работу с текстовыми файлами

15. Дан файл, содержащий текст на русском языке. Найти слово, встречающееся в каждом предложении, или сообщить, что такого слова нет.

#include //Кагарлык Евгения Васильевна

#include

#include

#include

#include

#include

#include

void stamp()

{

char name[] = "Student";

time_t t = time(NULL);

struct tm *tm = localtime(&t);

printf("\n%s\n", name);

printf("%s", asctime(tm));

}

#define SIT 100

#define WIS 100

#define WL 80

typedef struct Lengths

{

int SentNum;

int WordsNum;

} Lengths;

typedef struct Node

{

char *Word;

struct Node *next;

} PNode;

PNode *Head = NULL;

PNode *CreateNode(char *NewWord)

{

PNode *NewNode;

NewNode = (PNode *)malloc(sizeof(PNode));

NewNode->Word = (char *)malloc(strlen(NewWord) + 1);

strcpy(NewNode->Word, NewWord);

NewNode->next = NULL;

return NewNode;

}

PNode *AddFirst(PNode *head, PNode *NewNode)

{

if (*NewNode->Word != '\0')

{

NewNode->next = head;

return NewNode;

}

else

return head;

}

PNode *AddLast(PNode *head, PNode *NewNode)

{

PNode *p2;

int dub = 0;

if (head == NULL)

return NewNode;

for (p2 = head; p2->next != NULL; p2 = p2->next)

if (strcmp(NewNode->Word, p2->Word) == 0)

dub++;

if (dub == 0)

p2->next = NewNode;

return head;

}

PNode *AddMiddle(PNode *head, PNode *NewNode)

{

PNode *p1, *p2;

if (head == NULL)

{

head = AddFirst(head, NewNode);

return head;

}

p1 = head;

while (p1 != NULL)

{

if (*NewNode->Word != '\0')

head = AddLast(head, NewNode);

p1 = p1->next;

return head;

}

return head;

}

void reformatString(wchar_t *src)

{

for (; *src; ++src)

{

if (iswalpha(*src))

*src = (wchar_t)towlower((wchar_t)*src);

else

*src = '\0';

}

}

void ReadFile(char sentences[SIT][WIS][WL], Lengths *sizes)

{

setlocale(LC_CTYPE, "ru_RU.UTF-8");

wchar_t _word[WL], tmp[WL];

char word[WL], dot = '.';

int i = 0, j = 0, k = 0;

int n;

FILE *in;

in = fopen("C./c/test.txt", "r");

if (in == NULL)

{

printf("Ошибка! Файл не найден.\n");

exit(1);

}

while (1)

{

n = fwscanf(in, L"%ls", _word);

if (n <= 0)

break;

wcscpy(tmp, _word);

reformatString(_word);

wcstombs(word, _word, sizeof(word));

strcpy(sentences[i][j], word);

j++;

int lastCharIndex = wcslen(tmp) - 1;

if (tmp[lastCharIndex] == dot)

{

sizes[i].SentNum = i + 1;

sizes[i].WordsNum = j;

i++;

j = 0;

}

Head = AddMiddle(Head, CreateNode(word));

}

fclose(in);

}

void PrintList(PNode *head)

{

PNode *tracer = head;

while (tracer != NULL)

{

printf("%s\n", tracer->Word);

tracer = tracer->next;

}

}

void PrintSentences(char sentences[SIT][WIS][WL], Lengths *sizes)

{

for (int i = 0; i < sizes[i].SentNum; i++)

for (int j = 0; j < sizes[i].WordsNum; j++)

printf("%s ", sentences[i][j]);

printf("\n");

}

}

void SearchWords(PNode *head, char sentences[SIT][WIS][WL], Lengths *sizes)

{

char matches[SIT][WL] = {0};

char foundWord[WL];

int count = 0;

int arrLen = 0;

int index = 0;

for (int i = 0; i < sizes[i].SentNum; i++)

arrLen++;

PNode *tracer = head;

while (tracer != NULL)

{

for (int i = 0; i < sizes[i].SentNum; i++)

{

for (int j = 0; j < sizes[i].WordsNum; j++)

if (strcmp(sentences[i][j], tracer->Word) == 0)

{

count++;

strcpy(foundWord, tracer->Word);

}

}

if (count == arrLen)

{

strcpy(matches[index], foundWord);

index++;

}

count = 0;

tracer = tracer->next;

}

printf("\n");

printf("Слова, встречающие в каждом предложении: \n");

if (index != 0)

{

for (int i = 0; i < index; i++)

printf("%d: %s\n", i + 1, matches[i]);

}

else

printf("Таких слов нет\n");

}

int main(int argc, char **argv)

{

Lengths sizes[SIT];

char sentences[SIT][WIS][WL];

ReadFile(sentences, sizes);

PrintSentences(sentences, sizes);

SearchWords(Head, sentences, sizes);

stamp();

return 0;

}