#include <cstdio>   // C++ обгортка над stdio.h (рекомендовано в C++)
// або
#include <stdio.h>  // класичний C-заголовок (також працює в C++)

#include <cstdio>
#include <cstdlib>

int main()
{
    FILE* dataFile;

    // Відкриваємо файл для запису (текстовий режим)
    dataFile = fopen("students.txt", "w");

    if (dataFile == NULL)
    {
        fprintf(stderr, "Помилка: не вдалося відкрити файл students.txt\n");
        return 1;
    }

    // Файл успішно відкрито — записуємо дані
    fprintf(dataFile, "Іван Петренко, 20, 4.5\n");
    fprintf(dataFile, "Олена Коваль, 19, 4.8\n");

    fclose(dataFile);
    return 0;
}

#include <cstdio>

int main()
{
    FILE* logFile;
    int   closeResult;

    logFile = fopen("app.log", "w");
    if (logFile == NULL)
    {
        fprintf(stderr, "Помилка відкриття файлу\n");
        return 1;
    }

    fprintf(logFile, "Програма запущена\n");

    // Явно закриваємо і перевіряємо результат
    closeResult = fclose(logFile);
    if (closeResult != 0)
    {
        fprintf(stderr, "Помилка закриття файлу\n");
        return 1;
    }

    return 0;
}

#include <cstdio>

int main()
{
    FILE* dataFile;
    int   numbers[5] = { 10, 25, 37, 42, 58 };

    dataFile = fopen("numbers.txt", "w");
    if (dataFile == NULL)
    {
        fprintf(stderr, "Помилка: файл не відкрито\n");
        return 1;
    }

    // Записуємо кожен елемент масиву в окремий рядок файлу
    for (int i = 0; i < 5; i++)
    {
        fprintf(dataFile, "%d\n", numbers[i]);
    }

    fclose(dataFile);
    dataFile = NULL;

    fprintf(stdout, "Дані успішно записано у numbers.txt\n");
    return 0;
}

#include <cstdio>
#include <cstring>

struct Student
{
    char   name[50];
    int    age;
    double gpa;
};

int main()
{
    FILE*   dataFile;
    Student students[3] = {
        { "Іван Петренко", 20, 4.5 },
        { "Олена Коваль",  19, 4.8 },
        { "Михайло Бойко", 21, 3.9 }
    };

    dataFile = fopen("students.txt", "w");
    if (dataFile == NULL)
    {
        fprintf(stderr, "Не вдалося відкрити файл\n");
        return 1;
    }

    // Записуємо заголовок і дані кожного студента
    fprintf(dataFile, "%-25s %5s %6s\n", "Ім'я", "Вік", "ГПА");
    fprintf(dataFile, "%-25s %5s %6s\n", "-------------------------", "---", "------");

    for (int i = 0; i < 3; i++)
    {
        fprintf(dataFile, "%-25s %5d %6.2f\n",
                students[i].name,
                students[i].age,
                students[i].gpa);
    }

    fclose(dataFile);
    dataFile = NULL;

    return 0;
}

#include <cstdio>

int main()
{
    FILE* dataFile;
    int   value;
    int   count;

    dataFile = fopen("numbers.txt", "r");
    if (dataFile == NULL)
    {
        fprintf(stderr, "Файл numbers.txt не знайдено\n");
        return 1;
    }

    count = 0;
    fprintf(stdout, "Вміст файлу numbers.txt:\n");

    // Читаємо поки не кінець файлу
    while (fscanf(dataFile, "%d", &value) == 1)
    {
        fprintf(stdout, "[%d] %d\n", count, value);
        count++;
    }

    fprintf(stdout, "Всього прочитано елементів: %d\n", count);

    fclose(dataFile);
    dataFile = NULL;

    return 0;
}

#include <cstdio>

struct Student
{
    char   name[50];
    int    age;
    double gpa;
};

int main()
{
    FILE*   dataFile;
    Student buffer;
    int     count;

    // Попередньо запишемо дані без форматування (для читання fscanf)
    dataFile = fopen("raw_students.txt", "w");
    if (dataFile == NULL) { return 1; }

    fprintf(dataFile, "Petrenko 20 4.5\n");
    fprintf(dataFile, "Koval 19 4.8\n");
    fprintf(dataFile, "Boiko 21 3.9\n");
    fclose(dataFile);

    // Відкриваємо для читання
    dataFile = fopen("raw_students.txt", "r");
    if (dataFile == NULL)
    {
        fprintf(stderr, "Файл не знайдено\n");
        return 1;
    }

    count = 0;
    // Перший параметр fscanf — файл, далі — специфікатор і адреси змінних
    while (fscanf(dataFile, "%s %d %lf",
                  buffer.name, &buffer.age, &buffer.gpa) == 3)
    {
        fprintf(stdout, "%-15s | вік: %d | gpa: %.2f\n",
                buffer.name, buffer.age, buffer.gpa);
        count++;
    }

    fprintf(stdout, "\nПрочитано %d студентів\n", count);

    fclose(dataFile);
    return 0;
}

#include <cstdio>

int main()
{
    FILE* dataFile;
    int   ch;
    int   lineNum;
    int   lineLen;

    // Створимо тестовий файл
    dataFile = fopen("text.txt", "w");
    if (dataFile == NULL) { return 1; }
    fprintf(dataFile, "Hello, World!\n");
    fprintf(dataFile, "C programming\n");
    fprintf(dataFile, "File I/O\n");
    fclose(dataFile);

    // Відкриваємо для посимвольного читання
    dataFile = fopen("text.txt", "r");
    if (dataFile == NULL)
    {
        fprintf(stderr, "Файл не знайдено\n");
        return 1;
    }

    lineNum = 1;
    lineLen = 0;

    while ((ch = fgetc(dataFile)) != EOF)
    {
        if (ch == '\n')
        {
            fprintf(stdout, "Рядок %d: %d символів\n", lineNum, lineLen);
            lineNum++;
            lineLen = 0;
        }
        else
        {
            lineLen++;
        }
    }

    // Останній рядок без '\n'
    if (lineLen > 0)
    {
        fprintf(stdout, "Рядок %d: %d символів\n", lineNum, lineLen);
    }

    fclose(dataFile);
    return 0;
}

#include <cstdio>

int main()
{
    FILE* sourceFile;
    FILE* destFile;
    int   ch;

    sourceFile = fopen("text.txt", "r");
    if (sourceFile == NULL)
    {
        fprintf(stderr, "Вхідний файл не знайдено\n");
        return 1;
    }

    destFile = fopen("text_copy.txt", "w");
    if (destFile == NULL)
    {
        fprintf(stderr, "Не вдалося створити вихідний файл\n");
        fclose(sourceFile);
        return 1;
    }

    // Посимвольне копіювання
    while ((ch = fgetc(sourceFile)) != EOF)
    {
        fputc(ch, destFile);
    }

    fclose(sourceFile);
    fclose(destFile);

    fprintf(stdout, "Файл скопійовано у text_copy.txt\n");
    return 0;
}

#include <cstdio>

int main()
{
    FILE* dataFile;
    char  lineBuffer[256];
    int   lineNum;

    // Підготовка тестового файлу
    dataFile = fopen("poem.txt", "w");
    if (dataFile == NULL) { return 1; }
    fputs("Реве та стогне Дніпр широкий,\n", dataFile);
    fputs("Сердитий вітер завива,\n", dataFile);
    fputs("Додолу верби гне високі,\n", dataFile);
    fputs("Горами хвилю підійма.\n", dataFile);
    fclose(dataFile);

    // Читаємо рядок за рядком
    dataFile = fopen("poem.txt", "r");
    if (dataFile == NULL)
    {
        fprintf(stderr, "Файл poem.txt не знайдено\n");
        return 1;
    }

    lineNum = 0;
    while (fgets(lineBuffer, sizeof(lineBuffer), dataFile) != NULL)
    {
        lineNum++;
        fprintf(stdout, "%2d: %s", lineNum, lineBuffer);
    }

    fclose(dataFile);
    return 0;
}

#include <cstdio>

int main()
{
    FILE*  binFile;
    int    writeData[5] = { 100, 200, 300, 400, 500 };
    int    readData[5]  = { 0, 0, 0, 0, 0 };
    size_t written;
    size_t readCount;

    // --- Запис масиву в бінарний файл ---
    binFile = fopen("array.bin", "wb");
    if (binFile == NULL)
    {
        fprintf(stderr, "Помилка запису\n");
        return 1;
    }

    // Записуємо весь масив одним викликом
    written = fwrite(writeData, sizeof(int), 5, binFile);
    fprintf(stdout, "Записано елементів: %zu\n", written);

    fclose(binFile);

    // --- Читання масиву з бінарного файлу ---
    binFile = fopen("array.bin", "rb");
    if (binFile == NULL)
    {
        fprintf(stderr, "Помилка читання\n");
        return 1;
    }

    readCount = fread(readData, sizeof(int), 5, binFile);
    fprintf(stdout, "Прочитано елементів: %zu\n", readCount);

    fclose(binFile);

    // Виводимо прочитані дані
    fprintf(stdout, "Дані: ");
    for (int i = 0; i < (int)readCount; i++)
    {
        fprintf(stdout, "%d ", readData[i]);
    }
    fprintf(stdout, "\n");

    return 0;
}

#include <cstdio>
#include <cstring>

struct Student
{
    char   name[50];
    int    age;
    double gpa;
};

int main()
{
    FILE*   binFile;
    Student writeStudents[3];
    Student readStudents[3];

    // Заповнюємо структури
    strncpy(writeStudents[0].name, "Petrenko Ivan", 49);
    writeStudents[0].age = 20;
    writeStudents[0].gpa = 4.5;

    strncpy(writeStudents[1].name, "Koval Olena", 49);
    writeStudents[1].age = 19;
    writeStudents[1].gpa = 4.8;

    strncpy(writeStudents[2].name, "Boiko Mykhailo", 49);
    writeStudents[2].age = 21;
    writeStudents[2].gpa = 3.9;

    // --- Запис ---
    binFile = fopen("students.bin", "wb");
    if (binFile == NULL) { return 1; }

    // Записуємо весь масив структур одним викликом fwrite
    fwrite(writeStudents, sizeof(Student), 3, binFile);
    fclose(binFile);

    // --- Читання ---
    binFile = fopen("students.bin", "rb");
    if (binFile == NULL) { return 1; }

    size_t count = fread(readStudents, sizeof(Student), 3, binFile);
    fclose(binFile);

    // Виводимо прочитані дані
    for (size_t i = 0; i < count; i++)
    {
        fprintf(stdout, "%-20s | %d р. | GPA: %.2f\n",
                readStudents[i].name,
                readStudents[i].age,
                readStudents[i].gpa);
    }

    return 0;
}

#include <cstdio>

long getFileSize(const char* filename)
{
    FILE*    file;
    long     size;

    file = fopen(filename, "rb");
    if (file == NULL)
    {
        return -1;
    }

    // Переміщуємо покажчик у кінець файлу
    fseek(file, 0, SEEK_END);

    // Отримуємо поточну позицію — це і є розмір файлу
    size = ftell(file);

    fclose(file);
    return size;
}

int main()
{
    long size;

    size = getFileSize("students.bin");
    if (size == -1)
    {
        fprintf(stderr, "Файл не знайдено\n");
        return 1;
    }

    fprintf(stdout, "Розмір students.bin: %ld байтів\n", size);
    return 0;
}

#include <cstdio>
#include <cstring>

struct Student
{
    char   name[50];
    int    age;
    double gpa;
};

// Читає студента за індексом (0-based) з бінарного файлу
int readStudentAt(const char* filename, int index, Student* result)
{
    FILE*    file;
    long     offset;

    file = fopen(filename, "rb");
    if (file == NULL) { return -1; }

    // Переміщуємо покажчик до потрібного запису
    offset = (long)(index * sizeof(Student));
    if (fseek(file, offset, SEEK_SET) != 0)
    {
        fclose(file);
        return -1;
    }

    // Читаємо один запис
    if (fread(result, sizeof(Student), 1, file) != 1)
    {
        fclose(file);
        return -1;
    }

    fclose(file);
    return 0;
}

int main()
{
    Student s;

    // Читаємо другого студента (індекс 1)
    if (readStudentAt("students.bin", 1, &s) == 0)
    {
        fprintf(stdout, "Студент[1]: %s, вік %d, GPA %.2f\n",
                s.name, s.age, s.gpa);
    }

    // Читаємо третього студента (індекс 2)
    if (readStudentAt("students.bin", 2, &s) == 0)
    {
        fprintf(stdout, "Студент[2]: %s, вік %d, GPA %.2f\n",
                s.name, s.age, s.gpa);
    }

    return 0;
}

#include <cstdio>
#include <cstring>

struct Student
{
    char   name[50];
    int    age;
    double gpa;
};

// Оновлює GPA студента за індексом
int updateGpa(const char* filename, int index, double newGpa)
{
    FILE*    file;
    Student  s;
    long     offset;

    file = fopen(filename, "r+b");
    if (file == NULL) { return -1; }

    offset = (long)(index * sizeof(Student));
    fseek(file, offset, SEEK_SET);

    // Спочатку читаємо існуючий запис
    if (fread(&s, sizeof(Student), 1, file) != 1)
    {
        fclose(file);
        return -1;
    }

    // Модифікуємо поле
    s.gpa = newGpa;

    // Повертаємося до початку запису і записуємо оновлений
    fseek(file, offset, SEEK_SET);
    fwrite(&s, sizeof(Student), 1, file);

    fclose(file);
    return 0;
}

int main()
{
    Student s;
    FILE*   file;

    // Оновлюємо GPA другого студента
    if (updateGpa("students.bin", 1, 4.95) == 0)
    {
        fprintf(stdout, "GPA оновлено успішно\n");
    }

    // Перевіряємо результат
    file = fopen("students.bin", "rb");
    if (file != NULL)
    {
        fseek(file, sizeof(Student), SEEK_SET);
        fread(&s, sizeof(Student), 1, file);
        fclose(file);

        fprintf(stdout, "Оновлений запис: %s — GPA: %.2f\n", s.name, s.gpa);
    }

    return 0;
}

#include <cstdio>
#include <cstring>

int main()
{
    FILE* logFile;

    logFile = fopen("critical.log", "w");
    if (logFile == NULL) { return 1; }

    fprintf(logFile, "[START] Програма запущена\n");
    fflush(logFile);  // Гарантуємо запис на диск одразу

    // ... довга операція ...
    fprintf(logFile, "[INFO] Операція розпочата\n");
    fflush(logFile);  // Ще одне примусове скидання

    // Якщо після цього рядка програма впаде —
    // попередні записи вже є на диску
    fprintf(logFile, "[END] Завершено\n");

    fclose(logFile);
    return 0;
}

#include <cstdio>

int main()
{
    FILE* dataFile;
    int   value;

    dataFile = fopen("numbers.txt", "r");
    if (dataFile == NULL) { return 1; }

    // Читаємо всі числа
    while (fscanf(dataFile, "%d", &value) == 1)
    {
        fprintf(stdout, "%d\n", value);
    }

    // Перевіряємо, чому зупинились
    if (feof(dataFile))
    {
        fprintf(stdout, "\nДосягнуто кінець файлу\n");
    }
    else if (ferror(dataFile))
    {
        fprintf(stderr, "\nПомилка читання файлу!\n");
    }

    // Скидаємо прапорці і повертаємось до початку
    clearerr(dataFile);
    rewind(dataFile);

    // Тепер можемо читати знову
    fprintf(stdout, "Перше число: ");
    fscanf(dataFile, "%d", &value);
    fprintf(stdout, "%d\n", value);

    fclose(dataFile);
    return 0;
}

#include <cstdio>

int main()
{
    FILE*  dataFile;
    fpos_t savedPos;
    int    value;

    dataFile = fopen("numbers.txt", "r");
    if (dataFile == NULL) { return 1; }

    // Читаємо перші два числа
    fscanf(dataFile, "%d", &value);
    fprintf(stdout, "1-е: %d\n", value);

    fscanf(dataFile, "%d", &value);
    fprintf(stdout, "2-е: %d\n", value);

    // Зберігаємо поточну позицію
    fgetpos(dataFile, &savedPos);
    fprintf(stdout, "Позицію збережено\n");

    // Читаємо ще два числа
    fscanf(dataFile, "%d", &value);
    fprintf(stdout, "3-є: %d\n", value);

    fscanf(dataFile, "%d", &value);
    fprintf(stdout, "4-е: %d\n", value);

    // Відновлюємо збережену позицію
    fsetpos(dataFile, &savedPos);

    // Читаємо з тієї ж позиції знову
    fscanf(dataFile, "%d", &value);
    fprintf(stdout, "Знову 3-є: %d\n", value);

    fclose(dataFile);
    return 0;
}

#include <cstdio>
#include <cstring>
#include <cstdlib>

#define MAX_NAME_LEN 50
#define DB_FILENAME  "students.db"

struct Student
{
    char   name[MAX_NAME_LEN];
    int    age;
    double gpa;
    int    isActive;  // 1 = активний, 0 = видалений
};

// Додати студента у файл (дозапис)
int addStudent(const char* name, int age, double gpa)
{
    FILE*   dbFile;
    Student s;

    strncpy(s.name, name, MAX_NAME_LEN - 1);
    s.name[MAX_NAME_LEN - 1] = '\0';
    s.age      = age;
    s.gpa      = gpa;
    s.isActive = 1;

    dbFile = fopen(DB_FILENAME, "ab");
    if (dbFile == NULL) { return -1; }

    fwrite(&s, sizeof(Student), 1, dbFile);
    fclose(dbFile);
    return 0;
}

// Вивести всіх активних студентів
void listStudents()
{
    FILE*   dbFile;
    Student s;
    int     index;

    dbFile = fopen(DB_FILENAME, "rb");
    if (dbFile == NULL)
    {
        fprintf(stdout, "(база порожня)\n");
        return;
    }

    fprintf(stdout, "\n%-4s %-20s %-5s %-6s\n",
            "№", "Ім'я", "Вік", "GPA");
    fprintf(stdout, "----+--------------------+-----+------\n");

    index = 0;
    while (fread(&s, sizeof(Student), 1, dbFile) == 1)
    {
        if (s.isActive)
        {
            fprintf(stdout, "%-4d %-20s %-5d %.2f\n",
                    index, s.name, s.age, s.gpa);
        }
        index++;
    }

    fclose(dbFile);
}

// Знайти студента за ім'ям
int findStudent(const char* name, Student* result)
{
    FILE*   dbFile;
    Student s;
    int     index;

    dbFile = fopen(DB_FILENAME, "rb");
    if (dbFile == NULL) { return -1; }

    index = 0;
    while (fread(&s, sizeof(Student), 1, dbFile) == 1)
    {
        if (s.isActive && strncmp(s.name, name, MAX_NAME_LEN) == 0)
        {
            *result = s;
            fclose(dbFile);
            return index;
        }
        index++;
    }

    fclose(dbFile);
    return -1;  // Не знайдено
}

// Оновити GPA за індексом
int updateGpa(int index, double newGpa)
{
    FILE*   dbFile;
    Student s;
    long    offset;

    dbFile = fopen(DB_FILENAME, "r+b");
    if (dbFile == NULL) { return -1; }

    offset = (long)(index * sizeof(Student));
    fseek(dbFile, offset, SEEK_SET);

    if (fread(&s, sizeof(Student), 1, dbFile) != 1)
    {
        fclose(dbFile);
        return -1;
    }

    s.gpa = newGpa;

    fseek(dbFile, offset, SEEK_SET);
    fwrite(&s, sizeof(Student), 1, dbFile);

    fclose(dbFile);
    return 0;
}

int main()
{
    Student found;
    int     idx;

    // Додаємо кількох студентів
    addStudent("Petrenko Ivan",  20, 4.5);
    addStudent("Koval Olena",    19, 4.8);
    addStudent("Boiko Mykhailo", 21, 3.9);
    addStudent("Savchenko Anna", 20, 4.2);

    fprintf(stdout, "=== Список студентів ===");
    listStudents();

    // Пошук
    idx = findStudent("Koval Olena", &found);
    if (idx >= 0)
    {
        fprintf(stdout, "\nЗнайдено [%d]: %s, GPA: %.2f\n",
                idx, found.name, found.gpa);

        // Оновлюємо GPA
        updateGpa(idx, 4.95);
        fprintf(stdout, "GPA оновлено до 4.95\n");
    }

    fprintf(stdout, "\n=== Після оновлення ===");
    listStudents();

    return 0;
}

#include <cstdio>

int main()
{
    FILE* f;

    // Створимо тестовий файл
    f = fopen("temp.txt", "w");
    fprintf(f, "test data\n");
    fclose(f);

    // Перейменовуємо файл
    if (rename("temp.txt", "renamed.txt") == 0)
    {
        fprintf(stdout, "Файл перейменовано\n");
    }

    // Видаляємо файл
    if (remove("renamed.txt") == 0)
    {
        fprintf(stdout, "Файл видалено\n");
    }
    else
    {
        fprintf(stderr, "Помилка видалення\n");
    }

    return 0;
}