Heap corruption detected after normal block (#276) at 0x017D5DD0

#include <time.h>     // библиотека работы с таймером
#include <stdio.h>    // библиотека ввода-вывода
#include <stdlib.h>   // библиотека системных функций
#include <locale.h>   // библиотека языковой локализации
 
 
 
// Минимальный размер матрицы
const int minsize = 2;
// Максимальный размер матрицы
const int maxsize = 12;
// Минимальный диапазон случайных чисел
const int min_range = 8;
// Максимальный диапазон случайных чисел
const int max_range = 180;
// Длина имени файла
const int namelen = 66;
/*
   Функция резервирует память под матрицу и возвращает указатель на неё
*/
int** CreateMatrix(int rows, int cols)
{
    // Проверить размеры матрицы по измерениям
    if (rows < minsize || rows > maxsize ||
        cols < minsize || cols > maxsize) return NULL;
 
    // Зарезервировать память под одномерный массив указателей
    int** matrix = new int* [rows];
 
    // Убедиться, что память выделена
    if (matrix == NULL) return NULL;
 
    // Перемещаться по массиву указателей
    for (register int row = 0; row < rows; row++)
    {
        // Зарезервировать память под одномерный вектор-массив для хранения
        // значений матрицы и присоединить его к одномерному массиву указателей
        matrix[row] = new int[cols];
 
        // Убедиться, что память под вектор-массив выделена  
        if (matrix[row] == NULL)
        {
            // Удалить ранее выделенные одномерные массивы
            while ((--row) >= 0)
                // Удалить одномерные вектор-массивы
                delete[] matrix[row];
            // Удалить одномерный массив указателей
            delete[] matrix;
            // Вернуть результат в случае неуспеха 
            return NULL;
        }
    }  // Вернуть адрес матрицы при успехе
    return matrix;
}
/*
   Функция освобождает память из под матрицы и обнуляет управляющие переменные
*/
void DeleteMatrix(int& rows, int& cols, int**& matrix)
{
    // Убедиться, что память выделена
    if (matrix != NULL)
    {
        // Перемещаться по массиву указателей
        for (register int row = 0; row < rows; row++)
            // Удалять одномерные вектор-массивы ячеек, присоединенные к указателям
            delete[] matrix[row];
        // Удалить одномерный массив указателей
        delete[] matrix;
    }
    // Обнулить информацию о матрице
    matrix = NULL;
    rows = 0;
    cols = 0;
}
 
#pragma warning(disable: 4996)
/*
   Функция организует ввод значения в заданном диапазоне
*/
bool EntryValue(const char* name, int& value, int min = INT_MAX, int max = INT_MIN)
{
    // Число для ввода, статус проверки ввода
    int temp, check;
    // Вывести информацию о параметре
    if (name != NULL) printf("\nВведите %s", name);
 
    // Если диапазон не задан, то любое значение
    if (min == INT_MAX && max == INT_MIN)
    {
        printf(":>");
        min = INT_MIN;
        max = INT_MAX;
    }
    // Если задан только максимум, то значение может быть не больше заданного
    else if (min == INT_MAX && max != INT_MIN)
    {
        printf(" [< %d]:>", max);
        min = INT_MIN;
    }
    // Если задан только минимум, то значение может быть не меньше заданного
    else if (min != INT_MAX && max == INT_MIN)
    {
        printf(" [> %d]:>", min);
        max = INT_MAX;
    }
    // Если задан максимум и минимум, то значение находится в диапазоне
    else
        printf(" [%d..%d]:>", min, max);
 
    // Ввести значение числа
    check = scanf("%d", &temp);
 
    // Проверить корректность ввода и допустимость диапазона
    if (check != 1 || fgetchar() != 10 || temp < min || temp > max)
    {
        fflush(stdin);
        // Вывести сообщение об ошибке
        printf("Ошибка: Некорректный ввод для %s\n", ((name) ? name : "значения"));
        return false;
    }
    else
    {
        // Вернуть значене через аргумент
        value = temp;
        return true;
    }
}
/*
   Статическая функция вычисляет число ряда по номеру
*/
static int number = 7;
static int NextNumber()
{
    return (number += 7);
}/*
   Главная функция. Реализует ввод, проверку, интерфейс с пользователем.
*/
void main()
{
    int k = 1;
    int max = INT_MIN;
    int min = INT_MAX;
    int   pulley[] = { 0, 0 };          // Шапка параметров матрицы {строк, столбцов}
    int& rows = pulley[0];            // Количество строк матрицы
    int& cols = pulley[1];            // Количество столбцов матрицы
    char  ch = '\0';                    // Команда меню
    int   row, col, idx;                // Индекс строки, индекс столбца, просто индекс
    int   check, value;                 // Статус ввода, введенное значение
    int   range = max_range;            // Ширина диапазона случайных чисел
    int** matrix = NULL;                // Указатель на матрицу
    char  filename[namelen];            // Имя файла
    FILE* fp;                           // Указатель на файловой поток
 
    // Для сообщений на русском языке
    setlocale(LC_ALL, "Russian");
    printf("Лаба: Зигзаг");
 
    // Определить константу для шапки параметров матрицы
    const int heap = sizeof(pulley) / sizeof(int);
 
    // Инициализация генератора случайных чисел
    srand((unsigned int)time(NULL));
 
    do {                                // Обработка команд меню
        switch (ch)
        {
        case 'C':     // Ввод размера и резервирование матрицы
        case 'c':
            // Ввести количество строк матрицы и проверить корректность ввода
            if (!EntryValue("количество строк", row, minsize, maxsize)) break;
 
            // Ввести количество столбцов матрицы и проверить корректность ввода
            if (!EntryValue("количество столбцов", col, minsize, maxsize)) break;
 
            // Удалить текущую матрицу
            DeleteMatrix(rows, cols, matrix);
 
            // Зарезервировать память под матрицу для заданного размера
            if ((matrix = CreateMatrix(row, col)) == NULL)
            {
                printf("Ошибка: Недостаточно памяти\n");
                break;
            }
 
            // Запомнить новый размер матрицы
            rows = row;
            cols = col;
 
 
 
        case 'R':     // Заполнение матрицы случайными значениями
        case 'r':
            // Перемещаться по строкам матрицы
            for (row = 0; row < rows; row++)
                // Перемещаться по столбцам матрицы
                for (col = 0; col < cols; col++)
                    // Генерировать и запоминать случайные значения
                    matrix[row][col] = ((rand() % 2) ? +1 : -1) * (rand() % range);
 
 
 
        case 'P':     // Печать элементов матрицы
        case 'p':
            printf("\nТекущая матрица [%dx%d] %s\n", rows, cols,
                ((matrix) ? "содержит:" : "пуста!"));
 
            // Перемещаться по строкам матрицы
            for (row = 0; row < rows; row++)
            {
                printf("\n");
                // Перемещаться по столбцам матрицы
                for (col = 0; col < cols; col++)
                    // Выводить значение ячейки матрицы
                    printf("%6d", matrix[row][col]);
            }
            break;
 
 
        case 'D':     // Удаление матрицы
        case 'd':
            // Освободить память от матрицы
            DeleteMatrix(rows, cols, matrix);
            printf("\nМатрица пуста!");
            break;
 
 
        case 'E':     // Ввод всех элементов матрицы по порядку
        case 'e':
            // Перемещаться по строкам матрицы
            for (row = 0; row < rows; row++)
                // Перемещаться по столбцам матрицы
                for (col = 0; col < cols; col++)
                {
                    // Вводить новые значения для элементов матрицы
                    printf("\nМатрица[%d][%d]", row, col);
                    if (!EntryValue("ячейки", matrix[row][col], SHRT_MIN, SHRT_MAX)) col--;
                }
            break;
 
 
        case 'M':     // Изменение элемента матрицы по индексу
        case 'm':
            // Проверить, что матрица не пуста, т.е. есть что изменять
            if (matrix == NULL) break;
 
            // Ввести индекс строки и проверить корректность ввода
            if (!EntryValue("индекс строки", row, 0, rows - 1)) break;
 
            // Ввести индекс столбца и проверить корректность ввода
            if (!EntryValue("индекс столбца", col, 0, cols - 1)) break;
 
            // Ввести значение элемента и проверить корректность ввода
            if (!EntryValue("значение элемента", value, SHRT_MIN, SHRT_MAX)) break;
 
            // Запомнить новое значение в элементе матрицы
            matrix[row][col] = value;
            break;
 
 
        case 'I':     // Перестановка строк местами
        case 'i':
            // Проверить, что матрица не пуста, т.е. есть что изменять
            if (matrix == NULL) break;
 
            // Ввести индекс первой строки для обмена и проверить корректность ввода
            if (!EntryValue("индекс первой строки", row, 0, rows - 1)) break;
 
            // Ввести индекс второй строки для обмена и проверить корректность ввода
            if (!EntryValue("индекс второй строки", idx, 0, rows - 1)) break;
 
            if (row != idx)
                // Переставить значения элементов между строками (проход по столбцу)
                for (col = 0; col < cols; col++)
                {
                    value = matrix[row][col];
                    matrix[row][col] = matrix[idx][col];
                    matrix[idx][col] = value;
                }
            // Перейти к отображению текущей матрицы 
            ch = 'P';
            continue;
 
 
        case 'J':     // Перестановка столбцов местами
        case 'j':
            // Проверить, что матрица не пуста, т.е. есть что изменять
            if (matrix == NULL) break;
 
            // Ввести индекс первого столбца для обмена и проверить корректность ввода
            if (!EntryValue("индекс первого столбца", col, 0, cols - 1)) break;
 
            // Ввести индекс второго столбца для обмена и проверить корректность ввода
            if (!EntryValue("индекс второго столбца", idx, 0, cols - 1)) break;
 
            if (col != idx)
                // Переставить значения элементов между столбцами (проход по строке)
                for (row = 0; row < rows; row++)
                {
                    value = matrix[row][col];
                    matrix[row][col] = matrix[row][idx];
                    matrix[row][idx] = value;
                }
            // Перейти к отображению текущей матрицы 
            ch = 'P';
            continue;
 
 
        case 'B':        // Сохранение матрицы в бинарном файле
        case 'b':
        case 'S':        // Сохранение матрицы в текстовом файле
        case 's':
            fflush(stdin);
            // Ввести имя файла
            printf("\nВведите имя файла для сохранения (или нажмите [enter] для отмены):>");
            scanf("%s", filename);
 
            // Создать файл для сохранения матрицы
            if ((fp = fopen(filename, "w")) == NULL)
                printf("\nОшибка: Файл с указанным именем не может создан или открыт на запись\n");
            else
            {
                if (ch == 'b' || ch == 'B')
                {
                    // Записать размеры матрицы в бинарный файл как единый блок
                    fwrite(pulley, sizeof(int), heap, fp);
 
                    // Записать элементы матрицы в бинарный файл по-блочно
                    if (matrix != NULL)
                    {
                        // Пройти по массиву указателей
                        for (row = 0; row < rows; row++)
                            // Записывать одномерные вектор-массивы значений в бинарный файл 
                            fwrite(matrix[row], sizeof(int), cols, fp);
                    }
                }
                else if (ch == 's' || ch == 'S')
                {
                    // Записать размеры матрицы в текстовый файл
                    fprintf(fp, "%4d \t %d", rows, cols);
                    // Перемещаться по строкам матрицы
                    for (row = 0; row < rows; row++)
                    {
                        fprintf(fp, "\n");
                        // Перемещаться по столбцам матрицы
                        for (col = 0; col < cols; col++)
                            // Записывать элементы матрицы в текстовый файл поштучно
                            fprintf(fp, "%4d\t", matrix[row][col]);
                    }
                }
                // Закрыть файл
                fclose(fp);
                printf("\nМатрица сохранена успешно\n");
            }
            break;
 
 
        case 'L':        // Загрузка матрицы из файла
        case 'l':
        case 'O':
        case 'o':
            fflush(stdin);
            // Ввести имя файла
            printf("\nВведите имя файл для загрузки (или нажмите [enter] для отмены):>");
            scanf("%s", filename);
 
            // Открыть файл для загрузки матрицы
            if ((fp = fopen(filename, "r")) == NULL)
                printf("\nОшибка: Файл с указанным именем не может быть открыт на чтение\n");
            else
            {
                // Удалить текущую матрицу
                DeleteMatrix(rows, cols, matrix);
                check = 0;
 
                if (ch == 'o' || ch == 'O')
                    // Прочитать размеры матрицы из бинарного файла как единый блок
                    check += fread(pulley, sizeof(int), heap, fp);
                else if (ch == 'l' || ch == 'L')
                    // Прочитать размеры матрицы из текстового файла по отдельности
                    check += fscanf(fp, "%d", &rows);
                check += fscanf(fp, "%d", &cols);
 
                // Проверить корректность чтения размеров матрицы
                if (check == heap)
                {
                    // Проверить допустимость диапазона для каждого размера
                    if (rows >= minsize && rows <= maxsize && cols >= minsize && cols <= maxsize)
                    {
                        // Зарезервировать память под новую матрицу
                        matrix = CreateMatrix(rows, cols);
 
                        // Убедиться, что память выделена
                        if (matrix != NULL)
                        {
                            if (ch == 'o' || ch == 'O')
                            {
                                // Пройти по массиву указателей
                                for (check = 0, row = 0; row < rows; row++, check += cols)
                                    // Прочитать одномерные вектор-массивы значений из бинарного 
                                    // файла как единые блоки, т.е. по cols-элементов за раз
                                    if (fread(matrix[row], sizeof(int), cols, fp) != cols) break;
                            }
                            else if (ch == 'l' || ch == 'L')
                            {
                                // Перемещаться по строкам матрицы
                                for (check = 0, row = 0; row < rows; row++)
                                    // Перемещаться по столбцам матрицы
                                    for (col = 0; col < cols; col++, check++)
                                        // Прочитать элементы матрицы из текстового файла поштучно
                                        if (fscanf(fp, "%d", &matrix[row][col]) != 1) break;
                            }
                            // Если было прочитано rows*cols-элементов, то загрузка прошла успешно
                            if (check == rows * cols)
                            {
                                printf("\nМатрица загружена успешно\n");
                                // Закрыть файл
                                fclose(fp);
                                // Перейти к отображению текущей матрицы
                                ch = 'P';
                                continue;
                            }
                            // Удалить матрицу, в случае неудачи
                            DeleteMatrix(rows, cols, matrix);
                        }
                    }
                }
                // Обнулить размеры, если недостаточно памяти или размеры прочитаны некорректно
                else rows = cols = 0;
 
 
                // Если прочитать матрицу не удалось
                printf("\nОшибка: Некорректные данные (загрузка отменена, матрица удалена)\n");
                // Закрыть файл
                fclose(fp);
            }
            break;
 
 
        case 'A':     // Настройка диапазона случайных чисел
        case 'a':
            // Ввести ширину диапазона случайных чисел и проверить корректность ввода
            EntryValue("диапазон случайных чисел", range, min_range, max_range);
            break;
 
        case 'H':      //Отражение элементов относительно середины для выбранного столбца.
        case 'h':
            // Проверить, что матрица не пуста, т.е. есть что изменять
            if (matrix == NULL) break;
 
            // Ввести индекс столбца для изменения и проверить корректность ввода
            if (!EntryValue("индекс столбца", col, 0, cols - 1)) break;
 
            // Переставить значения элементов относительно центра
            for (row = 0; row < rows / 2; row++)
            {
                value = matrix[row][col];
                matrix[row][col] = matrix[rows - row - 1][col];
                matrix[rows - 1 - row][col] = value;
            }
            // Перейти к отображению текущей матрицы 
            ch = 'P';
            continue;
 
        case 'F':     // Вычисление характеристики по элементам матрицы
        case 'f':
            max = INT_MIN;
            min = INT_MAX;
 
            value = 0;
            // Перемещаться по строкам матрицы
            for (row = 0; row < rows; row++)
                // Перемещаться по столбцам матрицы
                for (col = 0; col < cols; col++)
                {
                    // Вычисление характеристики
                    if (row % 2 == 1) { if (matrix[row][col] > max) { max = matrix[row][col]; } }
                    if (col % 2 == 0) { if (matrix[row][col] < min) { min = matrix[row][col]; } }
                }
            value = max - min;
            printf("\nХарактеристика=%d\n", value);
            break;
 
 
        case 'Z':     // Заполнение матрицы по заданию
        case 'z':
            // Проверить, что матрица не пуста, т.е. есть что изменять
            if (matrix == NULL) break;
 
            // Если чётное количество элементов в матрице
            if ((rows * cols) % 2 == 0)
            {
                // Заполнение по диагонали с левого нижнего угла
                number = 7;
                row = rows - 1;
                col = 0;
                matrix[row][col] = 7;
                k = 0;
                for (int num = 1; num <= rows * cols; num++)
                {
                    if (k == 0)
                        if (row - 1 >= 0) k = -1;
                        else k = 1;
 
                    if (k == -1)
                    {
                        row--;
                        if (col + 1 <= cols - 1) k = 2;
                        else if (row - 1 >= 0 && col - 1 >= 0) k = -2;
                    }
 
                    else if (k == 2)
                    {
                        row = row++;
                        col = col++;
                        if (row == rows - 1) k = 1;
                        else if (col == cols - 1) k = -1;
                    }
 
                    else if (k == 1)
                    {
                        col = col++;
                        if (col + 1 <= cols - 1 && row + 1 <= rows - 1) k = 2;
                        else if (row - 1 >= 0) k = -2;
                    }
 
                    else if (k == -2)
                    {
                        row = row--;
                        col = col--;
                        if (row == 0) k = 1;
                        else if (col == 0) k = -1;
                    }
                    matrix[row][col] = NextNumber();
                }
            }
            // Если нечётное количество элементов в матрице
            else
            {
                // Заполнение по диагонали с правого верхнего угла
                number = 7;
                row = 0;
                col = cols - 1;
                matrix[row][col] = 7;
                k = 0;
                for (int num = 1; num <= rows * cols; num++)
                {
                    if (k == 0)
                        if (row - 1 >= 0) k = 1;
                        else k = -1;
 
                    if (k == -1)
                    {
                        col = col - 1;
                        if (row + 1 <= rows - 1) k = 2;
                        if (row - 1 >= 0 && col - 1 >= 0) k = -2;
                    }
 
                    else if (k == 2)
                    {
                        row = row + 1;
                        col = col + 1;
                        if (row == rows - 1) k = -1;
                        if (col == cols - 1) k = 1;
                    }
 
                    else if (k == 1)
                    {
                        row = row + 1;
                        if (col + 1 <= cols - 1 && row + 1 <= rows - 1) k = 2;
                        if (col - 1 >= 0) k = -2;
                    }
 
                    else if (k == -2)
                    {
                        row = row - 1;
                        col = col - 1;
                        if (row == 0) k = -1;
                        if (col == 0) k = 1;
                    }
                    matrix[row][col] = NextNumber();
                }
            }
            // Перейти к отображению текущего массива
            ch = 'p';
            continue;
 
        case '\0':    // Пустое действие
            break;
 
        default:
            printf("Ошибка: Некорректная операция");
        };
        // Сбросить устройство ввода
        while (getchar() != '\n');
        // Отображение консольного меню
        printf("\n\nГлавное меню:");
        printf("\nP. Печать матрицы");
        printf("\nC. Создание новой матрицы");
        printf("\nD. Удаление текущей матрицы");
        printf("\nF. Вычисление характеристики");
        printf("\nB. Сохранение матрицы в бинарном файле");
        printf("\nO. Загрузка матрицы из бинарного файла");
        printf("\nS. Сохранение матрицы в текстовом файле");
        printf("\nL. Загрузка матрицы из текстового файла");
        printf("\nA. Настройка диапазона случайных чисел");
        printf("\nI. Обмен элементами двух строк матрицы");
        printf("\nJ. Обмен элементами двух столбцов матрицы");
        printf("\nM. Изменение элемента матрицы по индексам");
        printf("\nE. Ввод всех элементов матрицы по порядку");
        printf("\nH. Отражение элементов относительно середины для выбранного столбца.");
        printf("\nZ. Заполнение матрицы зигзагом по заданию");
        printf("\nR. Заполнение матрицы случайными значениями");
        printf("\nQ. Выход");
        printf("\nВыберите пункт:>");
        ch = getchar();
    } while ((ch != 'Q') && (ch != 'q'));
 
    // Освободить память из под текущей матрицы
    DeleteMatrix(rows, cols, matrix);
}