source.cpp

#include "pch.h"
#include "Header.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <locale.h>

FILE* file_create(const char *filename, const char *mode)
{
    FILE *file = fopen(filename, mode);
    if (file == NULL)
    {
        fprintf(stderr, "Can't open file: %s\n", filename);
        return NULL;
    }

    return file;
}

struct connection* make_connection(const char *filename, const char *mode)
{
    struct connection *conn = (struct connection*)malloc(sizeof(struct connection));
    if (!conn)
    {
        fprintf(stderr, "Out of memory\n");
        return NULL;
    }

    conn->file = file_create(filename, mode);
    conn->classes = (struct clas*)malloc(sizeof(struct clas));
    if (!conn->classes)
    {
        fprintf(stderr, "Out of memory\n");
        free(conn);
        return NULL;
    }

    return conn;
}

int int_input()
{
    int i, n;

    do
    {
        i = scanf_s("%d", &n);
        if (!i)
        {
            rewind(stdin);
            printf("Invalid input\n");
            continue;
        }
    } while (!i);

    return n;
}

int stud_number()
{
    int numb;
    printf("Введите количество студентов:\n");

    do
    {
        numb = int_input();
    } while (numb <= 0);

    return numb;
}

struct student* set_student(struct student *st)
{
    int i;

    st->set = 1;

    printf("Имя:");
    rewind(stdin);
    gets_s(st->first_name, MAX_DATA);
    printf("Фамилия:");
    rewind(stdin);
    gets_s(st->second_name, MAX_DATA);
    printf("Отчество:");
    rewind(stdin);
    gets_s(st->patronimyc, MAX_DATA);

    printf("Номер класса:");
    st->year = int_input();
    printf("Буква класса:");
    rewind(stdin);
    st->letter = getchar();

    st->sum = 0;

    for (i = 0; i < MARKS; i++)
    {
        printf("Оценка № %d: ", i + 1);
        st->marks[i] = int_input();
        st->sum += st->marks[i];
    }

    return st;
}

int set_all(struct connection *conn)
{
    int i;
    int students_number = stud_number();

    for (i = 0; i < MAX_ROWS; i++)
    {
        conn->classes->rows[i].set = 0;
    }

    struct student *stud;

    for (i = 0; i < students_number; i++)
    {
        stud = &conn->classes->rows[i];
        stud = set_student(stud);
    }

    return students_number;
}

struct connection* delete_connection(struct connection *conn)
{
    int i;

    if (conn)
    {
        for (i = 0; i < MAX_ROWS; i++)
        {
            conn->classes->rows[i].set = 0;
        }

        if (conn->file)
        {
            fclose(conn->file);
            conn->file = NULL;
        }

        if (conn->classes)
        {
            free(conn->classes);
            conn->classes = NULL;
        }

        free(conn);
    }

    return NULL;
}

void print_student(struct student *stud)
{
    int i = 0;

    printf("%d%c ", stud->year, stud->letter);
    printf("%s %s %s\n", stud->first_name, stud->second_name, stud->patronimyc);

    printf("Оценки:\n");
    for (i = 0; i < MARKS; i++)
    {
        printf("%3d", stud->marks[i]);
    }
    printf("\n\n");
}

void print_all(struct clas *cl, int students_number)
{
    int i;

    for (i = 0; i < students_number; i++)
    {
        if (cl->rows[i].set == 1)
            print_student(&cl->rows[i]);
    }
}

void write(struct connection *conn)
{
    rewind(conn->file);

    int rc = fwrite(conn->classes, sizeof(struct clas), 1, conn->file);
    if (rc != 1)
    {
        fprintf(stderr, "Can't write data in file\n");
    }
}

struct connection* read(struct connection *conn)
{
    if (conn != NULL)
    {
        delete_connection(conn);
    }

    conn = make_connection("file", "rb");

    int rc = fread(conn->classes, sizeof(struct clas), 1, conn->file);
    if (rc > 1 || ferror(conn->file))
    {
        fprintf(stderr, "Can't load data from file\n");
    }

    return conn;
}

int define_student(struct student *stud)
{
    if (!stud->set)
    {
        return 0;
    }

    for (int i = 0; i < MARKS; i++)
    {
        if (stud->marks[i] <= 4)
        {
            return 0;
        }
    }

    return 1;
}

int print_good(struct clas *classes)
{
    int i = 0, j = 0, good = 0;

    printf("Ученики без четверок:\n");

    for (i = 0; i < MAX_ROWS; i++)
    {
        if (define_student(&classes->rows[i]))
        {
            print_student(&classes->rows[i]);
            good++;
        }
    }

    if (!good)
    {
        printf("Нет учеников без четверок\n");
    }
    else
    {
        printf("Всего учеников без четверок: %d\n", good);
    }

    return good;
}

int get_max_sum(struct student *rows, int students_number, int class_year)
{
    int i, max_sum = 0;

    for (i = 0; i < students_number; i++)
    {
        if (rows[i].year == class_year && rows[i].sum > max_sum && define_student(&rows[i]))
        {
            max_sum = rows[i].sum;
        }
    }

    return max_sum;
}

void student_copy(struct clas *destinition, struct clas *source, int des_indx, int sour_indx)
{
    strcpy(destinition->rows[des_indx].first_name, source->rows[sour_indx].first_name);
    strcpy(destinition->rows[des_indx].second_name, source->rows[sour_indx].second_name);
    strcpy(destinition->rows[des_indx].patronimyc, source->rows[sour_indx].patronimyc);

    destinition->rows[des_indx].set = 1;
    destinition->rows[des_indx].letter = source->rows[sour_indx].letter;
    destinition->rows[des_indx].year = source->rows[sour_indx].year;
    destinition->rows[des_indx].sum = source->rows[sour_indx].sum;

    for (int i = 0; i < MARKS; i++)
    {
        destinition->rows[des_indx].marks[i] = source->rows[sour_indx].marks[i];
    }
}

int students_cmp(struct student *stud1, struct student *stud2)
{
    if (stud1->set != 1 || stud2->set != 1)
    {
        return 0;
    }

    if (strcmp(stud1->first_name, stud2->first_name) != 0) return 0;
    if (strcmp(stud1->second_name, stud2->second_name) != 0) return 0;
    if (strcmp(stud1->patronimyc, stud2->patronimyc) != 0) return 0;
    if (stud1->sum != stud2->sum) return 0;

    return 1;
}

void remove_similar(struct student *rows)
{
    for (int i = 0; i < MAX_ROWS; i++)
    {
        for (int j = i + 1; j < MAX_ROWS; j++)
        {
            if (students_cmp(&rows[i], &rows[j]))
            {
                rows[j].set = 0;
            }
        }
    }
}

struct clas* find_best(struct clas *classes, int students_number)
{
    int class_year, i, j, max_sum = 0;
    int indx = 0;

    struct clas *best = (struct clas*)malloc(sizeof(struct clas));

    for (i = 0; i < students_number; i++)
    {
        class_year = classes->rows[i].year;
        max_sum = get_max_sum(classes->rows, students_number, class_year);

        for (j = i; j < students_number; j++)
        {
            if (classes->rows[j].year == class_year && classes->rows[j].sum == max_sum)
            {
                student_copy(best, classes, indx++, j);
            }
        }
    }

    remove_similar(best->rows);

    return best;
}

void print_best(struct clas *classes)
{
    int i = 0;
    int count = 0;

    printf("Лучшие ученики по сумме баллов в своем и параллельных классах:\n");

    for (i = 0; i < MAX_ROWS; i++)
    {
        if (classes->rows[i].set == 1)
        {
            print_student(&classes->rows[i]);
            count++;
        }
    }

    if (!count) printf("Нет учеников без четверок\n");
}

int obtain_max_row(char *str1, char *str2)
{
    int i = 0;

    while (*(str1 + i) != '\0' && *(str2 + i) != '\0')
    {
        if (str1[i] > str2[i]) return 1;
        else if (str2[i] > str1[i++]) return 0;
    }

    if (str1[i] == str2[i] == '\0') return 0;
    if (str1[i] == '\0') return 0;

    return 1;
}

void sort(struct clas *clas)
{
    int i, j, max_indx;

    for (i = 0; i < MAX_ROWS - 1; i++)
    {
        struct student key = clas->rows[i];
        max_indx = i;

        for (j = i + 1; j < MAX_ROWS; j++)
        {
            if (key.set && clas->rows[j].set)
            {
                if (obtain_max_row(key.first_name, clas->rows[j].first_name))
                {
                    max_indx = j;
                    key = clas->rows[j];
                }
            }
        }

        clas->rows[max_indx] = clas->rows[i];
        clas->rows[i] = key;
    }
}

float get_average(struct clas *clas)
{
    int i = 0;
    float gen_sum = 0.0, average = 0.0;
    int numb = 0;

    for (i = 0; i < MAX_ROWS; i++)
    {
        if (clas->rows[i].set)
        {
            gen_sum += clas->rows[i].sum;
            numb++;
        }
    }

    average = gen_sum / MARKS / numb;

    return average;
}

struct student* read_n(struct connection *conn)
{
    rewind(conn->file);
    fpos_t pos;
    fgetpos(conn->file, &pos);

    printf("Введите номер записи для считывания:\n");
    int n = int_input();

    for (int i = 0; i < MAX_ROWS && i < n - 1; i++)
    {
        fseek(conn->file, sizeof(struct student), SEEK_CUR);
    }

    struct student *stud = (struct student*)malloc(sizeof(struct student));
    int rc = fread(stud, sizeof(struct student), 1, conn->file);
    if (rc < 1)
    {
        fprintf(stderr, "Can't read data\n");
        return NULL;
    }

    return stud;
}