Функции: исключить строки матрицы с повторяющимися элементами

#include "pch.h"
#include <stdio.h>
#include <locale.h>
#include <math.h>
#include <iostream>
#pragma warning(disable : 4996)
 
//прототип функции очистки памяти
void mem_clear(int **MASS, int m);
//прототип функции ввода количества строк
int m_rows();
//прототип функции ввода количества столбцов
int n_cols();
//прототип функции ввода матрицы
int** ent_m(int m, int n);
//прототип функции подсчета матрицы
int** calc_m(int **INIT_MASS, int m, int n, int *p);
//прототип функции вывода меню
void menu();
//прототип функции вывода матрицы
void prt(int **INIT_MASS, int m, int n);
 
 
int main()
{
 
    int **INIT_MASS = NULL; //Вводимая матрица
    int **RES_MASS = NULL;  //Новая матрица
    int i,          //Счетчик цикла
        j,          //Счетчик цикла
        k,          //Счетчик цикла
        m,          //Количество строк в матрице
        n,          //Количество столбцов в матрице
        flag_line,      //Проверка условия
        line,       //Количество строк в новой матрице
        flag_ex,    //Проверка для выхода
        flag_n,     //Проверка ввода количества столбцов
        flag_m,     //Проверка ввода количества строк
        flag_mx,    //Проверка ввода матрицы
        flag_c;     //Проверка вычисления результата
    char M;         //Управление меню
 
                //Инициализация переменных
    flag_ex = 1;
    flag_n = 0;
    flag_m = 0;
    flag_mx = 0;
    flag_c = 0;
    do
    {
        //вызов функции меню
        menu();
        //ввод переменной, которая определяет меню
        scanf("%c%*c", &M);
        switch (M)
        {
            //Ввод строк
        case 'm':
            //Очистка памяти
            if (flag_mx == 1)
                mem_clear(INIT_MASS, m);
            if (flag_c == 1)
                mem_clear(RES_MASS, line);
            //получение кол-ва строк
             m = m_rows();
            flag_m = 1;
            flag_c = 0;
            flag_mx = 0;
            break;
 
            //Ввод столбцов
        case 'n':
            //Очистка памяти
            if (flag_mx == 1)
                mem_clear(INIT_MASS, m);
            if (flag_c == 1)
                mem_clear(RES_MASS, line);
            n = n_cols();
            flag_n = 1;
            flag_c = 0;
            flag_mx = 0;
            break;
 
            //ввод матрицы
        case 'e':
            //Очистка памяти
            if (flag_mx == 1)
                mem_clear(INIT_MASS, m);
            //Проверка достаточности входных данных
            if (flag_m == 0)
                printf("Enter number of lines, please!\n");
            if (flag_n == 0)
                printf("Enter number of columns, please!\n");
            if (flag_n == 1 && flag_m == 1)
            {
                INIT_MASS = ent_m(m, n);
                flag_c = 0;
                flag_mx = 1;
                puts("Matrix entered");
            }
            system("pause");
            break;
 
            //Вычисление результата
        case 'c':
            //Очистка памяти
            if (flag_c == 1)
                mem_clear(RES_MASS, line);
 
            //Проверка входных данных
            if (flag_m == 0)
                printf("Enter number of lines, please!\n");
            if (flag_n == 0)
                printf("Enter number of columns, please!\n");
            if (flag_mx == 0 && flag_m == 1 && flag_n == 1)
                printf("Enter the matrix, please!\n");
 
            if (flag_m == 1 && flag_n == 1 && flag_mx == 1)
            {
                calc_m(INIT_MASS, m, n, &line);
                flag_c = 1;
                puts("Result is calculated!\n");
            }
            system("pause");
            break;
 
        case 'd':
            //Проверка достаточности входных данных
            if (flag_m == 0)
                printf("Enter number of lines, please!\n");
            else
                printf("Number of lines: %d\n", m);
            if (flag_n == 0)
                printf("Enter number of columns, please!\n");
            else
                printf("Number of columns: %d\n", n);
 
            if (flag_mx == 0 && flag_m == 1 && flag_n == 1)
                printf("Enter the matrix, please!\n");
            //Вывод введенной матрицы
            if (flag_m == 1 && flag_n == 1 && flag_mx == 1)
            {
                prt(INIT_MASS, m, n);
            }
            system("pause");
            break;
 
        case 'r':
            //Проверка входных данных
            if (flag_m == 0)
                printf("Enter number of lines, please!\n");
            if (flag_n == 0)
                printf("Enter number of columns, please!\n");
            if (flag_mx == 0 && flag_m == 1 && flag_n == 1)
                printf("Enter the matrix, please!\n");
            if (flag_mx == 1 && flag_m == 1 && flag_n == 1 && flag_c == 0)
                printf("Calculate the result, please!\n");
            if (flag_c == 1 && flag_mx == 1)
            {
                if (line != 0)
                {
                    prt(RES_MASS, line, n);
                }
                else
                    printf("All the lines have repeating numbers!\n");
            }
            system("pause");
            break;
 
        case 'q':
            puts("Program has stopped!");
            flag_ex = 0;
            break;
 
        default:
            printf("Wrong symbol, try again!\n");
            system("pause");
        }
    } while (flag_ex == 1);
    //Очистка памяти
    mem_clear(INIT_MASS, m);
    mem_clear(RES_MASS, line);
    system("pause");
    return 0;
}
 
void mem_clear(int **MASS, int m)
{
    int i;
    for (i = 0; i < m; i++)
        if (MASS[i] != NULL)
            free(MASS[i]);
    if (MASS != NULL)
        free(MASS);
}
 
int m_rows()
{
    int m;
    do
    {
        printf("Number of the lines: ");
        scanf("%d%*c", &m);     //Ввод m
        if (m <= 1)
            puts("Number entered wrong, m > 2! Try again!");
    } while (m <= 1);
    return m;
}
 
int n_cols()
{
    int n;
    do
    {
        printf("Number of the coloums: ");
        scanf("%d%*c", &n);     //Ввод n
        if (n < 1)
            puts("Number entered wrong, n > 1! Try again!");
    } while (n < 1);
    return n;
}
 
int** ent_m(int m, int n)
{
    int **INIT_MASS = NULL;
    int i;
    int j;
    //Выделение памяти под массив указателей (матрицу)
    INIT_MASS = (int**)malloc(m * sizeof(int*));
    for (i = 0; i < m; i++)
    {
        *(INIT_MASS + i) = (int*)malloc(n * sizeof(int));
        //Выделение памяти под строку в матрице
        for (j = 0; j < n; j++)
            scanf("%d%*c", *(INIT_MASS + i) + j);
        //Ввод элементов матрицы
    }
    return INIT_MASS;
}
 
int** calc_m(int **INIT_MASS, int m, int n, int *line)
{
    int **RES_MASS;
    int i;
    int j;
    int k;
    int flag_line;
 
    RES_MASS = (int**)malloc(m * sizeof(int*));
    for (i = 0; i < m; i++)
        RES_MASS[i] = NULL;
    *line = 0;
    for (i = 0; i < m; i++)
    {
        flag_line = 1;
        for (j = 0; (j < n) && flag_line; j++)
            for (k = 0; (k < j) && flag_line; k++)
                if (*(*(INIT_MASS + i) + j) ==
                    *(*(INIT_MASS + i) + k))
                    flag_line = 0;
 
        if (flag_line == 1)
        {
            //Выделение памяти для нового элемента
            *(RES_MASS + *line) = (int*)realloc(*(RES_MASS +
                *line), (n) * sizeof(int*));
            for (j = 0; j < n; j++)
                *(*(RES_MASS + *line) + j) = *(*(INIT_MASS
                    + i) + j);
            (*line)++;
        }
    }
    printf("%d\n",RES_MASS);
    return RES_MASS;
}
 
void prt(int **MASS, int m, int n)
{
    int i;
    int j;
    for (i = 0; i < m; i++)
    {
        for (j = 0; j < n; j++)
            printf("%3d ", *(*(MASS + i) + j));
        printf("\n");
    }
    printf("Matrix has size %d on %d \n", m, n);
}
 
 
void menu()
{
    system("cls");
    puts("m - Entering number of lines:\nn - Entering number of columns:\ne - Entering matrix : ");
    puts("c - Calculating result\nr - Printing result:");
    puts("d - Printing entered data:\nq - Quit from the program");
}

        case 'c':
            //Очистка памяти
            if (flag_c == 1)
                mem_clear(RES_MASS, line);
 
            //Проверка входных данных
            if (flag_m == 0)
                printf("Enter number of lines, please!\n");
            if (flag_n == 0)
                printf("Enter number of columns, please!\n");
            if (flag_mx == 0 && flag_m == 1 && flag_n == 1)
                printf("Enter the matrix, please!\n");
 
            if (flag_m == 1 && flag_n == 1 && flag_mx == 1)
            {
                RES_MASS = calc_m(INIT_MASS, m, n, &line);          //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
                flag_c = 1;
                puts("Result is calculated!\n");
            }
            system("pause");
            break;