Ошибка в коде при работе с динамической памятью

#include "stdio.h"
#include "locale.h"
#include "malloc.h"//для определения динамических массивов
#include <iostream>
#include <cstdlib>
 
 
 
//***********************
//**Прототипы функций****
//***********************
int &prost_B(int *b, int n, int *count_B);//формирует массив из простых чисел
int index_min(int *b, int n);//находим первый минимальный элемент массива
int index_max(int *b, int n);//находим последний максимальный элемент массива
int &delete_element(int *b, int n, int *j);//Удаляет все элементы массива B, сумма цифр которых кратна 7
void max_chet_sequence(int *a, int n);//находит максимальную последовательность из четных чисел
void sort_array(int *b, int index1, int index2);//сортирует элементы массива методом прямого обмена
 
void create(int* arr, int n);//создает массив
void show(int* arr, int n);//Выводит элементы массива на экран
 
 
 
 
using namespace std;
 
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
int main()
{
    setlocale(LC_ALL, "rus");
    
    int N;//кол-во элементов динамическом массиве А
    int answer2 = 100;//хранит номер вопроса
    int *A = 0;
    int *B = 0;
    int index_min_B;//хранит индекс минимального элемента массива B
    int index_max_B;//Хранит индекс максимального элемента массива B
    int count_B = 0;//считает кол-во элементов в массиве B
    int z = 0;//будет хранить кол-во элементов массива A - сумма цирф которых кратна 7
    int j = 0;//будет хранить кол-во элементов массива B- сумма цирф которых кратна 7
    
    
    
while (answer2 != 0) {
        system("cls");
        printf("Лабораторная работа №6 Бикеева А. И. Вариант 1\n\n");
        printf("Задание 2\n");
        printf("Меню\n");
        printf("1) Заполнить массив A\n");
        printf("2) Вывести массив A\n");
        printf("3) Отсортировать массив B методом прямого обмена\n");
        printf("4) Создать массив B из простых чисел массива А\n");
        printf("5) Вывод самой длинной последовательности четных чисел массива A\n");
        printf("6) Удаление элементов массива A, сумма цифр которых кратна 7\n");
        printf("7) Удаление элементов массива B, сумма цифр которых кратна 7\n");
        printf("8) Вывод массива B\n");
        printf("0) Выход\n");
        printf("Ваш выбор: ");
        while (!(cin >> answer2)){     //делаем проверку на ввод букв   
            cout << "error-Вы ввели символ не входящий в меню\nВаш выбор: ";          
            cin.clear();                
            fflush(stdin);              
            }
        system("cls");
        printf("Лабораторная работа №6 Бикеева А. И. Вариант 1\n\n");
        switch (answer2)
        {
            case 0:{
                break;
            }
            case 1: {
            printf("\tВведите кол-во элементов в массиве A: ");
            
            while (!(cin >> N)){ //делаем проверку на ввод букв        
            cout << "error\n";          
            cin.clear();                
            fflush(stdin);              
            }
                A = (int*)malloc(N);//создаем динамический массив запросив у ДП область памяти в N байт
                if(!A)
                {
                    A = (int*)malloc(N);//создаем динамический массив запросив у ДП область памяти в N байт
                }
                printf("Введите %d элементов массива: ", N);
                create(A, N);
                break;  
            
            system("pause");
            break;
        }
        case 2: {
            cout << "\tВывод массива A\n";
            show(A, N);
            system("pause");
            break;
        }
        case 3: {
            if(count_B)
            {
                printf("\tСоздаем отсортированный массив B\n\n");
                index_min_B = index_min(B, count_B);
                printf("Индекс первого минимального элемента массива B = %d\n", index_min_B);
    
                index_max_B = index_max(B, count_B);
                printf("Индекс последнего максимального  элемента массива B = %d\n", index_max_B);
    
                if (index_min_B != index_max_B)//если их индексы не совпадают, то сделать сортирвоку
                {
                    sort_array(B, index_min_B, index_max_B);
                    printf("Массив отсортирован\n");
                }
            }
            else
            {
                printf("Динамический массив B - пустой. Заполните массив А(если еще этого не сделали)\nВ ином случаи массив А не имеет простых чисел\n");
            }
            
            system("pause");
            break;
        }
        case 4: {
            printf("\tФормирование массива В из элементов массива А, являющихся простыми числами.\n\n");
            B = &prost_B(A, N, &count_B);//с помощью функции формируем новый массив B, содержащий только простые числа из массива A
        
            if(!B)
            {
                B = &prost_B(A, N, &count_B);//с помощью функции формируем новый массив B, содержащий только простые числа из массива A
                
            }
            printf("Массив В сформирован\n");
            
            system("pause");
            break;
        }
        case 5: {
            printf("Вывод самой длинной последовательности четных чисел массива A\n\n");
            max_chet_sequence(A, N);
            system("pause");
            break;
        }
        case 6: {
            cout << "Удаление элементов массива A, сумма цифр которых кратна 7\n\n";
            
            A = &delete_element(A, N, &z);
            N = z;
            printf("Удаление завершено\n");
            
            system("pause");
            break;
        }
        case 7:{
            if(count_B)
            {
                cout << "Удаление элементов массива B, сумма цифр которых кратна 7\n\n";
            
                B = &delete_element(B, count_B, &j);
                count_B = j;
                printf("Удаление завершено\n");
            }
            else
            {
                printf("Динамический массив B - пустой. Заполните массив А(если еще этого не сделали)\nВ ином случаи массив А не имеет простых чисел\n");
            }
            
            
            system("pause");
            break;
        }
        case 8: {
            if(count_B)//если в массиве А есть простые числа то ...
            {   
                cout << "\tВывод массива B\n";
                show(B, count_B);
            }
            else{
                printf("Динамический массив B - пустой. Заполните массив А(если еще этого не сделали)\nВ ином случаи массив А не имеет простых чисел\n");
            }
            
            system("pause");
            break;
        }
        default:
            {
                printf("Вы ввели не существующий номер вопроса\n");
            }
            break;
        }
    }
 
 
    system("pause");
    return 0;
}
 
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 
 
//***********************
//**Реализация функций***
//***********************
int &prost_B(int *b, int n, int *count_B)
{
    int *new_B = (int*)malloc(n);//создаем динаммический массив, который вернется в качестве результата функции
    if(!new_B)
    {
        int *new_B = (int*)malloc(n);//создаем динаммический массив, который вернется в качестве результата функции
    }
    
    int index_new_B = 0;//хранит размер нового динамического массива
    int k = 0;//проверяет число на простоту
 
    for (int i = 0; i < n; i++)//цикл проходит по каждому элементу из массива А
    {
        for (int l = 2; l < abs(b[i]); l++)//перебираем цифры и делим на данный элемент массива
        {
            if (abs(b[i]) % l == 0)//проверка числа на простату
            {
                k++;//если число не простое, то k++
            }
        }
        if (k == 0)//если число простое, то ....
        {
            new_B[index_new_B] = b[i];//записываем найденное простое число из массива А в массив B
            index_new_B++;
        }
 
        k = 0;//обнуляем для проверки на простоту следующего числа
        *count_B = index_new_B;
    }
    if (index_new_B != n)//если размер массива изменился, то ..
    {
        realloc(new_B, sizeof(int)*(index_new_B));//удаляем ненужные элементы в массиве new_B
    }
    
 
    return *new_B;//возвращаем в место вызова функции динамический массив элементы которого состоят из простых чисел дин. массива А
}
 
 
int index_min(int *b, int n)//находит первый минимальный индекс элемента массива
{
    int min = b[0];//сохраняем элемент массива с индексом 0 как минимальный элеммент массива
    int index_min = 0;//хранит индекс минимального элемента
    for (int i = 1; i < n; i++)
    {
        if (min > b[i])
        {
            min = b[i];
            index_min = i;
        }
    }
 
    return index_min;
}
 
int index_max(int *b, int n)//находит последний максимальный индекс элемента массива
{
    int max = b[0];//сохраняем элемент массива с индексом 0 как максимальный элеммент массива
    int index_max = 0;//хранит индекс мксимального элемента
    for (int i = 1; i < n; i++)
    {
        if (max < b[i])//если данный элемент больше либо равен максимуму, то ..
        {
            max = b[i];//запоминаем его значение
            index_max = i;//запоминаем его индекс
        }
    }
 
    return index_max;
}
 
void sort_array(int *b, int index1, int index2)
{
    if (index1 > index2)//если индекс минимального элемента массива находится дальше чем индекс максималнього элемента массива, то поменять их местами
    {
        int m = index1;
        index1 = index2;
        index2 = m;
    }
    int max = b[index1];
    for (int k = index1; k <= index2; k++)//повторяет один и тот же процесс столько раз - сколько элементов в данном диапозоне
    {
        for (int j = index1; j <= index2 - index1 - 1; j++)//перебирает элементы массива с первого минимального по последнего максимального
            if (b[j] > b[j + 1])//если элемент массива стоящий слева - больше элемента массива стоящего справа - обменяться местами
            {
                
                max = b[j + 1];
                b[j + 1] = b[j];
                b[j] = max;
            }
    }
}
 
int &delete_element(int *b, int n, int *index_C)
{
    int *C = (int*)malloc(n);//создает новый масссив, который по окончанию функции передаст тот же массив B и , но без чисел, сумма цифр которых кратна 7
    
    if(!C)
    {
        int *C = (int*)malloc(n);//создает новый масссив, который по окончанию функции передаст тот же массив B и , но без чисел, сумма цифр которых кратна 7
    
    }
    
    int sum = 0;//хранит сумму цифр одного из элементов массива
    int k;//будет хранить копию элемента массива
    int p = 0;//хранит кол-во элементов обновленного массива B, сумма цифр которой кратна 7
 
    for (int i = 0; i < n; i++)
    {
        k = b[i];
        while (k)//суммируем все числа i-ого элемента массива
        {
            sum += k % 10;
            k /= 10;
        }
        if (sum % 7 != 0)
        {
            C[p] = b[i];
            p++;
        }
        sum = 0;//обнуляем сумму для следующего лемента массива
    }
 
    *index_C = p;//новая длина массива B
    if (*index_C != n)
    {
        realloc(C, sizeof(int)*(p));//удаляем ненужные элементы в массиве С
    }
    
 
 
    return *C;
}
 
void max_chet_sequence(int *a, int n)
{
    int index_max1 = n;
    int index_max2 = n;
    
    
    
    int *max1 = (int*)malloc(index_max1);
    if(!max1)
    {
        int *max1 = (int*)malloc(index_max1);
    }
    
    int *max2 = (int*)malloc(index_max2);
    if(!max2)
    {
        int *max2 = (int*)malloc(index_max2);
    }
    
    
    int k = 0;//хранит кол-во подряд идующих четных элементов
    int k_max = 0;//максимальная серия из подряд идущих четных чисел
 
    for (int i = 0; i < n; i++)//пробегаем по всем элементам массива А
    {
        if ((a[i] % 2 == 0))
        {
            max1[k] = a[i];
            k++;
        }
        else
        {
            if (k_max < k)//если серия четных чисел больше, то сохраним ее во втором массиве
            {
                k_max = k;//обновляем серию
                for (int i = 0; i < k_max; i++)
                {
                    max2[i] = max1[i];
                }
            }
 
            k = 0;//обнуляем в случаи окончании серии четных чисел
        }
        if (i == (n - 1))
        {
            if (k_max < k)//если серия четных чисел больше, то сохраним ее во втором массиве
            {
                k_max = k;
                for (int i = 0; i < k_max; i++)
                {
                    max2[i] = max1[i];
                }
            }
            k = 0;
        }
 
    }
    if(k_max == 0)
    {
        printf("Такой последовательности нет\n");
    }
    else
    {
        printf("Выведем максимальную последователньость четных чисел из массива А\n");
 
        for (int i = 0; i <k_max; i++)
        {
            printf("Элемент массива с индексом %d равен: %d\n", i, max2[i]);
        }
    }
 
 
 
 
}
 
 
void create(int* arr, int n)//заполнение массива
{           
    for (int i = 0; i < n; i++) {
        cin >> arr[i];
    }
}
 
 
void show(int* arr, int n)//вывод массива
{               
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
}

#include "stdio.h"
#include "locale.h"
#include "malloc.h"//для определения динамических массивов
#include <iostream>
#include <cstdlib>
 
 
 
//***********************
//**Прототипы функций****
//***********************
int &prost_B(int *b, int n, int *count_B);//формирует массив из простых чисел
int index_min(int *b, int n);//находим первый минимальный элемент массива
int index_max(int *b, int n);//находим последний максимальный элемент массива
int &delete_element(int *b, int n, int *j);//Удаляет все элементы массива B, сумма цифр которых кратна 7
void max_chet_sequence(int *a, int n);//находит максимальную последовательность из четных чисел
void sort_array(int *b, int index1, int index2);//сортирует элементы массива методом прямого обмена
 
void create(int* arr, int n);//создает массив
void show(int* arr, int n);//Выводит элементы массива на экран
 
 
 
 
using namespace std;
 
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
int main()
{
    setlocale(LC_ALL, "rus");
    
    int N;//кол-во элементов динамическом массиве А
    int answer2 = 100;//хранит номер вопроса
    int *A = 0;
    int *B = 0;
    int index_min_B;//хранит индекс минимального элемента массива B
    int index_max_B;//Хранит индекс максимального элемента массива B
    int count_B = 0;//считает кол-во элементов в массиве B
    int z = 0;//будет хранить кол-во элементов массива A - сумма цирф которых кратна 7
    int j = 0;//будет хранить кол-во элементов массива B- сумма цирф которых кратна 7
    
    
    
while (answer2 != 0) {
        system("cls");
        printf("Лабораторная работа №6 Бикеева А. И. Вариант 1\n\n");
        printf("Задание 2\n");
        printf("Меню\n");
        printf("1) Заполнить массив A\n");
        printf("2) Вывести массив A\n");
        printf("3) Отсортировать массив B методом прямого обмена\n");
        printf("4) Создать массив B из простых чисел массива А\n");
        printf("5) Вывод самой длинной последовательности четных чисел массива A\n");
        printf("6) Удаление элементов массива A, сумма цифр которых кратна 7\n");
        printf("7) Удаление элементов массива B, сумма цифр которых кратна 7\n");
        printf("8) Вывод массива B\n");
        printf("0) Выход\n");
        printf("Ваш выбор: ");
        while (!(cin >> answer2)){     //делаем проверку на ввод букв   
            cout << "error-Вы ввели символ не входящий в меню\nВаш выбор: ";          
            cin.clear();                
            fflush(stdin);              
            }
        system("cls");
        printf("Лабораторная работа №6 Бикеева А. И. Вариант 1\n\n");
        switch (answer2)
        {
            case 0:{
                break;
            }
            case 1: {
            printf("\tВведите кол-во элементов в массиве A: ");
            
            while (!(cin >> N)){ //делаем проверку на ввод букв        
            cout << "error\n";          
            cin.clear();                
            fflush(stdin);              
            }
                A = (int*)malloc(sizeof(int)*N);//создаем динамический массив запросив у ДП область памяти в N байт
                if(!A)
                {
                    A = (int*)malloc(sizeof(int)*N);//создаем динамический массив запросив у ДП область памяти в N байт
                }
                printf("Введите %d элементов массива: ", N);
                create(A, N);
                break;  
            
            system("pause");
            break;
        }
        case 2: {
            cout << "\tВывод массива A\n";
            show(A, N);
            system("pause");
            break;
        }
        case 3: {
            if(count_B)
            {
                printf("\tСоздаем отсортированный массив B\n\n");
                index_min_B = index_min(B, count_B);
                printf("Индекс первого минимального элемента массива B = %d\n", index_min_B);
    
                index_max_B = index_max(B, count_B);
                printf("Индекс последнего максимального  элемента массива B = %d\n", index_max_B);
    
                if (index_min_B != index_max_B)//если их индексы не совпадают, то сделать сортирвоку
                {
                    sort_array(B, index_min_B, index_max_B);
                    printf("Массив отсортирован\n");
                }
            }
            else
            {
                printf("Динамический массив B - пустой. Заполните массив А(если еще этого не сделали)\nВ ином случаи массив А не имеет простых чисел\n");
            }
            
            system("pause");
            break;
        }
        case 4: {
            printf("\tФормирование массива В из элементов массива А, являющихся простыми числами.\n\n");
            B = &prost_B(A, N, &count_B);//с помощью функции формируем новый массив B, содержащий только простые числа из массива A
        
            if(!B)
            {
                B = &prost_B(A, N, &count_B);//с помощью функции формируем новый массив B, содержащий только простые числа из массива A
                
            }
            printf("Массив В сформирован\n");
            
            system("pause");
            break;
        }
        case 5: {
            printf("Вывод самой длинной последовательности четных чисел массива A\n\n");
            max_chet_sequence(A, N);
            system("pause");
            break;
        }
        case 6: {
            cout << "Удаление элементов массива A, сумма цифр которых кратна 7\n\n";
            
            A = &delete_element(A, N, &z);
            N = z;
            printf("Удаление завершено\n");
            
            system("pause");
            break;
        }
        case 7:{
            if(count_B)
            {
                cout << "Удаление элементов массива B, сумма цифр которых кратна 7\n\n";
            
                B = &delete_element(B, count_B, &j);
                count_B = j;
                printf("Удаление завершено\n");
            }
            else
            {
                printf("Динамический массив B - пустой. Заполните массив А(если еще этого не сделали)\nВ ином случаи массив А не имеет простых чисел\n");
            }
            
            
            system("pause");
            break;
        }
        case 8: {
            if(count_B)//если в массиве А есть простые числа то ...
            {   
                cout << "\tВывод массива B\n";
                show(B, count_B);
            }
            else{
                printf("Динамический массив B - пустой. Заполните массив А(если еще этого не сделали)\nВ ином случаи массив А не имеет простых чисел\n");
            }
            
            system("pause");
            break;
        }
        default:
            {
                printf("Вы ввели не существующий номер вопроса\n");
            }
            break;
        }
    }
 
 
    system("pause");
    return 0;
}
 
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 
 
//***********************
//**Реализация функций***
//***********************
int &prost_B(int *b, int n, int *count_B)
{
    int *new_B = (int*)malloc(sizeof(int)*n);//создаем динаммический массив, который вернется в качестве результата функции
    if(!new_B)
    {
        int *new_B = (int*)malloc(sizeof(int)*n);//создаем динаммический массив, который вернется в качестве результата функции
    }
    
    int index_new_B = 0;//хранит размер нового динамического массива
    int k = 0;//проверяет число на простоту
 
    for (int i = 0; i < n; i++)//цикл проходит по каждому элементу из массива А
    {
        for (int l = 2; l < abs(b[i]); l++)//перебираем цифры и делим на данный элемент массива
        {
            if (abs(b[i]) % l == 0)//проверка числа на простату
            {
                k++;//если число не простое, то k++
            }
        }
        if (k == 0)//если число простое, то ....
        {
            new_B[index_new_B] = b[i];//записываем найденное простое число из массива А в массив B
            index_new_B++;
        }
 
        k = 0;//обнуляем для проверки на простоту следующего числа
        *count_B = index_new_B;
    }
    if (index_new_B != n)//если размер массива изменился, то ..
    {
        realloc(new_B, sizeof(int)*(index_new_B));//удаляем ненужные элементы в массиве new_B
    }
    
 
    return *new_B;//возвращаем в место вызова функции динамический массив элементы которого состоят из простых чисел дин. массива А
}
 
 
int index_min(int *b, int n)//находит первый минимальный индекс элемента массива
{
    int min = b[0];//сохраняем элемент массива с индексом 0 как минимальный элеммент массива
    int index_min = 0;//хранит индекс минимального элемента
    for (int i = 1; i < n; i++)
    {
        if (min > b[i])
        {
            min = b[i];
            index_min = i;
        }
    }
 
    return index_min;
}
 
int index_max(int *b, int n)//находит последний максимальный индекс элемента массива
{
    int max = b[0];//сохраняем элемент массива с индексом 0 как максимальный элеммент массива
    int index_max = 0;//хранит индекс мксимального элемента
    for (int i = 1; i < n; i++)
    {
        if (max < b[i])//если данный элемент больше либо равен максимуму, то ..
        {
            max = b[i];//запоминаем его значение
            index_max = i;//запоминаем его индекс
        }
    }
 
    return index_max;
}
 
void sort_array(int *b, int index1, int index2)
{
    if (index1 > index2)//если индекс минимального элемента массива находится дальше чем индекс максималнього элемента массива, то поменять их местами
    {
        int m = index1;
        index1 = index2;
        index2 = m;
    }
    int max = b[index1];
    for (int k = index1; k <= index2; k++)//повторяет один и тот же процесс столько раз - сколько элементов в данном диапозоне
    {
        for (int j = index1; j <= index2 - index1 - 1; j++)//перебирает элементы массива с первого минимального по последнего максимального
            if (b[j] > b[j + 1])//если элемент массива стоящий слева - больше элемента массива стоящего справа - обменяться местами
            {
                
                max = b[j + 1];
                b[j + 1] = b[j];
                b[j] = max;
            }
    }
}
 
int &delete_element(int *b, int n, int *index_C)
{
    int *C = (int*)malloc(sizeof(int)*n);//создает новый масссив, который по окончанию функции передаст тот же массив B и , но без чисел, сумма цифр которых кратна 7
    
    if(!C)
    {
        int *C = (int*)malloc(sizeof(int)*n);//создает новый масссив, который по окончанию функции передаст тот же массив B и , но без чисел, сумма цифр которых кратна 7
    
    }
    
    int sum = 0;//хранит сумму цифр одного из элементов массива
    int k;//будет хранить копию элемента массива
    int p = 0;//хранит кол-во элементов обновленного массива B, сумма цифр которой кратна 7
 
    for (int i = 0; i < n; i++)
    {
        k = b[i];
        while (k)//суммируем все числа i-ого элемента массива
        {
            sum += k % 10;
            k /= 10;
        }
        if (sum % 7 != 0)
        {
            C[p] = b[i];
            p++;
        }
        sum = 0;//обнуляем сумму для следующего лемента массива
    }
 
    *index_C = p;//новая длина массива B
    if (*index_C != n)
    {
        realloc(C, sizeof(int)*(p));//удаляем ненужные элементы в массиве С
    }
    
 
 
    return *C;
}
 
void max_chet_sequence(int *a, int n)
{
    int index_max1 = n;
    int index_max2 = n;
    
    
    
    int *max1 = (int*)malloc(sizeof(int)*index_max1);
    if(!max1)
    {
        int *max1 = (int*)malloc(sizeof(int)*index_max1);
    }
    
    int *max2 = (int*)malloc(sizeof(int)*index_max2);
    if(!max2)
    {
        int *max2 = (int*)malloc(sizeof(int)*index_max2);
    }
    
    
    int k = 0;//хранит кол-во подряд идующих четных элементов
    int k_max = 0;//максимальная серия из подряд идущих четных чисел
 
    for (int i = 0; i < n; i++)//пробегаем по всем элементам массива А
    {
        if ((a[i] % 2 == 0))
        {
            max1[k] = a[i];
            k++;
        }
        else
        {
            if (k_max < k)//если серия четных чисел больше, то сохраним ее во втором массиве
            {
                k_max = k;//обновляем серию
                for (int i = 0; i < k_max; i++)
                {
                    max2[i] = max1[i];
                }
            }
 
            k = 0;//обнуляем в случаи окончании серии четных чисел
        }
        if (i == (n - 1))
        {
            if (k_max < k)//если серия четных чисел больше, то сохраним ее во втором массиве
            {
                k_max = k;
                for (int i = 0; i < k_max; i++)
                {
                    max2[i] = max1[i];
                }
            }
            k = 0;
        }
 
    }
    if(k_max == 0)
    {
        printf("Такой последовательности нет\n");
    }
    else
    {
        printf("Выведем максимальную последователньость четных чисел из массива А\n");
 
        for (int i = 0; i <k_max; i++)
        {
            printf("Элемент массива с индексом %d равен: %d\n", i, max2[i]);
        }
    }
 
 
 
 
}
 
 
void create(int* arr, int n)//заполнение массива
{           
    for (int i = 0; i < n; i++) {
        cin >> arr[i];
    }
}
 
 
void show(int* arr, int n)//вывод массива
{               
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
}

    if (*index_C != n)
    {
        realloc(C, sizeof(int)*(p));//óäàëÿåì íåíóæíûå ýëåìåíòû â ìàññèâå Ñ
        if(!C)
        {
            realloc(C, sizeof(int)*(p));//óäàëÿåì íåíóæíûå ýëåìåíòû â ìàññèâå Ñ
        }
    }

new_B = (int*)realloc(new_B, sizeof(int)*(index_new_B));
        if(!new_B)
        {
            new_B = (int*)realloc(new_B, sizeof(int)*(index_new_B));
        }