include stdio include malloc структура для задания строки матрицы type

#include <stdio.h>
#include <malloc.h>

//структура для задания строки матрицы
typedef struct Line {
    int n;	//количество элементов в строке массива
    int* a;	//массив элементов
} Line;

// структура для задания самой матрицы
typedef struct Matrix {
    int lines;	//количество строк матрицы
    Line* matr;	// массив строк матрицы
} Matrix;

// прототипы функций
int getInt(int*);// ввод целого числа
int input(Matrix *a); // ввод матрицы
void output(const char *msg, Matrix a); // вывод матрицы
void erase(Matrix *a);// освобождение занятой памяти
Matrix conv(Matrix *a);

// основная фукнция
int main()
{
    Matrix matr = {0, NULL}; //исходный массив
    // ввод матрицы
    if (input(&matr) == 0){
        printf("%s:\n", "End of file occured");
        return 1;
    }
    output("Source matrix", matr);
    Matrix new_matr = conv(&matr);
    output("Result matrix", new_matr);
    //освобождение памяти
    erase(&matr);
    erase(&new_matr);
    return 0;
}

// ввод целого числа
// при обнаружении ошибки ввод повторяется
// функция возвращает 1, если ввод корректен,
// и 0 при обнаружении конца файла
int getInt(int* a)
{
    int n;
    do {
        n = scanf_s("%d", a, sizeof(int));
        if (n < 0)	// обнаружен конец файла
            return 0;
        if (n == 0) {		// обнаружен некорректный символ - ошибка
            printf("%s\n", "Erorr! Repeat input");
            scanf_s("%*c", 0);
        }
    } while (n == 0);
    return 1;
}

// функция ввода матрицы
// функция возвращает 1б если ввод корректен, и 0 приобнаружении конца файла
// если конец файла обнаружен в середине ввода - нужно освободить выделенную память

int input(Matrix* rm)
{
    const char* pr = ""; // будущее сообщение об ошибке
    int m; //количество строк матрицы
    int i, j;
    int* p;
    // сначала вводим количество строк
    do {
        printf("%s\n", pr);
        printf("Enter number of lines:-->");
        pr = "Erorr! Repeat input!";
        if (getInt(&m) == 0)
            return 0; //обнаружен конец файла
    } while (m < 1);
    rm->lines = m;

    // выделяем память под массив структур - строк матрицы
    rm->matr = (Line*)calloc(m, sizeof(Line));

    for (i = 0; i < rm->lines; ++i) {
        // для каждой строки матрицы вводим количество столбцов
        pr = "";
        do {
            printf("%s\n", pr);
            printf("Enter items of line %d: --> ", i + 1);
            pr = "Erorr! Repeat input!";
            if (getInt(&m) == 0) {
                // освобождение выделенной памяти
                rm->lines = i; // сколько строк сформировано, память выделена
                //erase(rm);
                return 0; // обнаружен конец файла
            }
        } while (m < 1);
        rm->matr[i].n = m;
        // выделяем необходимую память под элементы строки
        p = (int*)malloc(sizeof(int) * m);
        rm->matr[i].a = p;

        // вводятся сами элементы данной строки матрицы
        printf("Enter element of matrix #%d:\n", i + 1);
        for (j = 0; j < m; ++j, ++p)
        {
            if (getInt(p) == 0) {
                // освобождение выделенной памяти
                rm->lines = i + 1;//выделена память и под текущую, i-ю строку
                erase(rm);
                return 0;
            }
        }

    }
    return 1;
}

// функция вывода матрицы
void output(const char* msg, Matrix a)
{
    int i, j;
    int* p;
    printf("%s:\n", msg);
    for (i = 0; i < a.lines; ++i) {
        p = a.matr[i].a;
        for (j = 0; j < a.matr[i].n; ++j, ++p)
            printf("%d ", *p);
        printf("\n");
    }
}

// функция освобождения занятой памяти
void erase(Matrix* a)
{
    int i;
    for (i = 0; i < a->lines; ++i)
        free(a->matr[i].a);
    free(a->matr);
    a->lines = 0;
    a->matr = NULL;
}

//функция для создания новой матрицы
Matrix conv(Matrix* a) {
    //создание новой матрицы
    Matrix matr = { 0, NULL };
    //копирование число строк
    matr.lines = a->lines;
    //выделение памяти для строк
    matr.matr = (Line*)calloc(a->lines, sizeof(Line));

    int i;
    for (i = 0; i < matr.lines; ++i) {
        //копирование число столбцов в строке
        matr.matr[i].n = a->matr[i].n;
        //выделение памяти под строки
        matr.matr[i].a = (int*)malloc(sizeof(int) * a->matr[i].n);
    }
    for (i = 0; i < a->lines; ++i) {
        int j = 0;
        int index_perv_bolsh = 0;
        int index_posl_menshe = 0;
        int flag_perv_bolshe = 0;
        //сохраняем 0 элемент как предыдущий
        int pred = a->matr[i].a[j];
        matr.matr[i].a[0] = a->matr[i].a[j];
        for (j = 1; j < a->matr[i].n; ++j) {
            //если текущий элемент больше предыдущего
            if (a->matr[i].a[j] > pred) {
                //если это первый элемент больше предыдущего
                if (flag_perv_bolshe == 0) {
                    //сохраняем номер элемента
                    index_perv_bolsh = j;
                    flag_perv_bolshe = 1;
                }
            }
            else if (a->matr[i].a[j] < pred)
            //сохраняем номер элемента меньше следующего
                index_posl_menshe = j;
            if (index_posl_menshe==0)
                index_posl_menshe=index_perv_bolsh;
            //перезаписываем предыдущий элемент
            pred = a->matr[i].a[j];
            //копирование элемента матрицы
            matr.matr[i].a[j] = a->matr[i].a[j];
        }
        //перестановка элементов местами
        int t = matr.matr[i].a[index_perv_bolsh];
        matr.matr[i].a[index_perv_bolsh] = matr.matr[i].a[index_posl_menshe];
        matr.matr[i].a[index_posl_menshe] = t;
    }
    return matr;
}