Почему вылетает ошибка "файл вызвал срабатывание точки останова"?

@ZlayaLola · Регистрация: 09.03.2018

Author24 — интернет-сервис помощи студентам

Уже который день мучаюсь с сортировками
Тестируешь, вроде всё нормально, но потом вылетает ошибка, скрин которой прикреплён
Смогла вычислить, что дело в быстрой сортировке или в её реализации, потому что без неё программа работает без ошибок
Посмотрите, пожалуйста, и помогите исправить
Сразу говорю, в программировании новичок, но очень хочу научиться, поэтому слишком умные слова по коду не пойму
По заданию: надо отсортировать строки в матрице по убыванию сумм цифр элементов

C++

#include "stdafx.h"
#include <locale>
#include <iostream>
#include <time.h>
#include <Windows.h>
#include <stdio.h>
#include <conio.h>
#include <iomanip>
 
using namespace std;
 
int vivod(float var1, float var2, int** var3);
 
int **copy(float var1, float var2, int** var3);
 
int bubble(float var1, float var2, int** var3);
int srav_counter;
int swap_counter;
 
int selection(float var1, float var2, int** var3);
int srav_count;
int swap_count;
 
int insert(float var1, float var2, int** var3r);
int sr_counter;
int sw_counter;
 
int Shell(float var1, float var2, int** var3);
int sw_count;
int sr_count;
 
void QuickSort(int* var3, int from, int to);
//int quick(int l, int r, int* var3);
int srav_counteer;
int swap_counteer;
 
void Tabl();
 
int main()
{
 
    float n; //количество строк
    float m; //количество столбцов
 
    setlocale(LC_ALL, "rus");
 
    cout << "Количество строк равно - ";
    cin >> n;
    cout << "Количество столбцов равно - ";
    cin >> m;
    cout << endl;
 
    while ((n != int(n)) || (n < 0) || (n == 0) || (m != int(m)) || (m < 0) || (m == 0))
    {
        cout << "Размер матрицы может быть задан только положительными целыми числами" << endl;
        cout << "Введите снова количество строк ";
        cin >> n;
        cout << "Введите снова количество столбцов ";
        cin >> m;
    }
 
    srand(time(NULL));
 
    int **array = (int**)malloc(n * sizeof(int*)); // Выделение памяти под указатели на строки
    // Ввод элементов массива
    for (int i = 0; i<n; i++)  // цикл по строкам
    {
        array[i] = (int*)malloc(m * sizeof(int)); // Выделение памяти под хранение строк
        for (int j = 0; j<m; j++)  // цикл по столбцам
        {
            array[i][j] = rand() % 10;
        }
    }
 
    cout << "\nНеотсортированный массив\n";
    vivod(n, m, array);
 
    int **arr = (int**)malloc(n*sizeof(int*)); //копия
    for (int i = 0; i < n; i++)
    {
        arr[i] = (int*)malloc(m*sizeof(int));
    }
    arr = copy(n, m, array);
 
    int **mass = (int**)malloc(n * sizeof(int*)); //копия
    for (int i = 0; i < n; i++)
    {
        mass[i] = (int*)malloc(m * sizeof(int));
    }
    mass = copy(n, m, array);
 
    int **massiv = (int**)malloc(n * sizeof(int*)); //копия
    for (int i = 0; i < n; i++)
    {
        massiv[i] = (int*)malloc(m * sizeof(int));
    }
    massiv = copy(n, m, array);
 
    int **mas = (int**)malloc(n * sizeof(int*)); //копия
    for (int i = 0; i < n; i++)
    {
        mas[i] = (int*)malloc(m * sizeof(int));
    }
    mas = copy(n, m, array);
 
    cout << "\nМассив, отсортированный методом пузырька\n";
    bubble(n, m, array);
    vivod(n, m, array);
 
    cout << "\nМассив, отсортированный методом выбора\n";
    selection(n, m, arr);
    vivod(n, m, arr);
 
    cout << "\nМассив, отсортированный методом вставок\n";
    insert(n, m, mass);
    vivod(n, m, mass);
 
    cout << "\nМассив, отсортированный методом Шелла\n";
    Shell(n, m, massiv);
    vivod(n, m, massiv);
 
    /*cout << "\nМассив, отсортированный методом быстрой сортировки\n";
    int *a = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            a[j] = mas[i][j];
        }
 
        QuickSort(a, 0,m-1);
 
        for (int h = 0; h<m; h++)
            cout << setw(6) << a[h];
        cout << endl;
    }
    cout << endl;*/
 
    cout << "\nМассив, отсортированный методом быстрой сортировки\n";
    int *a = new int[n];
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            a[j] = mas[i][j];
        }
 
        QuickSort(a, 0, m-1);
 
        for (int h = 0; h<m; h++)
            cout << setw(6) << a[h];
        cout << endl;
        
        //delete[] &a[i];
        //delete a;
 
    }
    cout << endl;
    //for (int i = 0; i < n; i++) // освобождаем память для всех строк
    //  delete[] &a[i];
    delete[] mas;
 
 
 
    Tabl();
 
    for (int i = 0; i < n; i++)  // цикл по строкам
        free(array[i]);   // освобождение памяти под строку
    free(array);
 
    system("pause");
    return 0;
}
 
int vivod(float var1, float var2, int** var3) //функция вывода двумерного массива
{
    int i, j;
 
    for (i = 0; i < var1; i++)
    {
        for (j = 0; j < var2; j++)
        {
            cout << setw(6) << var3[i][j];
        }
        cout << endl;
    }
    cout << endl;
    return 0;
}
 
int **copy(float var1, float var2, int** var3) //функция копирования двумерного массива
{
    int i, j;
 
    int **arr = (int**)malloc(var1 * sizeof(int*)); //копия
    for (int i = 0; i < var1; i++)
    {
        arr[i] = (int*)malloc(var2 * sizeof(int));
    }
    for (i = 0; i<var1; i++)
        for (j = 0; j < var2; j++)
        {
            arr[i][j] = var3[i][j];
        }
    return arr;
}
 
int bubble(float var1, float var2, int** var3) //функция сортировки пузырьком
{
    int s;
    for (int i = 0; i < var1; i++)
    {
        
        for (int j = (var2 - 1); j >=0 ; j--)
        {
            s = 0;
            for (int k = 0; k < j; k++)
            {
                srav_counter++; //счётчик сравнений
                if (abs(var3[i][k] % 10 + var3[i][k] / 10) < abs(var3[i][k+1] % 10 + var3[i][k+1] / 10))
                {
                    swap(var3[i][k+1], var3[i][k]); //перестановка
                    s++;
                }
            }
            swap_counter = swap_counter + s;//счётчик перестановок
            if (s == 0)
            break;
        }
    }
    return 0;
}
 
int selection(float var1, float var2, int** var3) //функция сортировки массива методом выбора
{
    int max_j, max;
    for (int i = 0; i < var1; i++)
    {
        for (int j = 0; j<(var2-1); j++)
        {
            max_j = j;
            max = abs(var3[i][j] % 10 + var3[i][j] / 10);
            for (int k = j + 1; k < var2; k++)
            {
                srav_count++; //счётчик сравнений
                if (abs(var3[i][k] % 10 + var3[i][k] / 10) > abs(var3[i][max_j] % 10 + var3[i][max_j] / 10))
                {
                    max_j = k;
                    max = abs(var3[i][k] % 10 + var3[i][k] / 10);
                }
            }
            if (max != abs(var3[i][j] % 10 + var3[i][j] / 10))
            {
                swap(var3[i][j], var3[i][max_j]);
                swap_count++; //счётчик перестановок
            }
        }
    }
    return 0;
}
 
int insert(float var1, float var2, int** var3) //функция сортировки массива методом вставок
{
    int i, j, k, x, sum;
 
            for (i = 0; i < var1; i++)
            {
                for (j = 1; j < (var2); j++)
                {
                    sum = abs(var3[i][j] % 10 + var3[i][j] / 10);
                    x = var3[i][j];
                    sr_counter++; //счётчик сравнений
                    for (k = j - 1; (k >= 0) && (abs(var3[i][k] % 10 + var3[i][k] / 10) < sum); (k--))
                    {
                        var3[i][k + 1] = var3[i][k];
                        sw_counter++; //счётчик перестановок
                        sr_counter++; //счётчик сравнений
                    }
                    var3[i][k + 1] = x;
                }
            }
    return 0;
}
 
int Shell(float var1, float var2, int** var3)
{
    int d = var2 / 2;
    while (d > 0)
    {
        for (int i = 0; i < var1; i++)
        {
            for (int j = 0; j < var2 - d; j++)
            {
                int k = j;
                sr_count++;
                while (k >= 0 && (abs(var3[i][k] % 10 + var3[i][k] / 10) < abs(var3[i][k + d] % 10 + var3[i][k + d] / 10)))
                {
                    swap(var3[i][k + d], var3[i][k]);
                    sw_count++;
                    /*sr_count++;*/
                    k--;
                }
                
            }
        }
        d = d / 2;
    }
    return 0;
}
 
void QuickSort(int* var3, int from, int to)
{
    int x, i, j, temp;
    if (from >= to) return; // условие окончания рекурсии
    i = from; // рассматриваем элементы с A[from] до A[to]
    j = to;
    x = var3[(from + to) / 2]; // выбрали средний элемент
    while (i < j)
    {
        if (var3[i] > x)
            i++;
        if (var3[j] < x)
            j--;
        if ((var3[i] <= x) && (var3[j] >= x))
        {
            swap(var3[i], var3[j]);
            i++;
            j--;
        }
    }
        QuickSort(var3, from, j); // сортируем левую часть
        QuickSort(var3, i, to); // сортируем правую часть
}
 
void Tabl() //функция создания и вывода сравнительной таблицы
{
    cout << "Сравнительная таблица эффективности методов сортировки двумерных массивов" << endl;
    printf("___________________________________________________________________________\n");
    printf("|            |Bubble Sort|Selection Sort|Insert Sort|Shell Sort|Quick Sort|\n");
    printf("|____________|___________|______________|___________|__________|__________|\n");
    printf("|Перестановки|%11i|%14i|%11i|%10i|%10i|\n", swap_counter, swap_count, sw_counter, sw_count, swap_counteer);
    printf("|____________|___________|______________|___________|__________|__________|\n");
    printf("|  Сравнения |%11i|%14i|%11i|%10i|%10i|\n", srav_counter, srav_count, (sr_counter-1), sr_count, srav_counteer);
    printf("|____________|___________|______________|___________|__________|__________|\n");
}

@_stanislav · 09.03.2018, 09:58

ZlayaLola, у тебя на скрине код другой. не понятно что вызвало твою ошибку, какая функция из твоего кода.

@Ygg · 09.03.2018, 11:22

После развале по стеку в отладчике бывает непонятно что случилось, иногда помогает поставить точку останова до развала, а затем пройтись по шагам F10 до точки вылета. Хотя, похоже вы вполне определили место вылета (пытались закомментировать строки приводящие к вылету), но так и не смогли понять причину.

Поменяйте автозаменой все float на int.

Динамическая память выделяется и освобождается с ошибками. Программа работает, но с утечками.

C++

    int **arr = (int**)malloc(n*sizeof(int*)); // !!!!
    for (int i = 0; i < n; i++)
    {
        arr[i] = (int*)malloc(m*sizeof(int));
    }
    arr = copy(n, m, array);
...
 
int **copy(float var1, float var2, int** var3) //функция копирования двумерного массива
{
    int i, j;
 
    int **arr = (int**)malloc(var1 * sizeof(int*)); //!!!
    for (int i = 0; i < var1; i++)
    {
        arr[i] = (int*)malloc(var2 * sizeof(int));
    }
    for (i = 0; i<var1; i++)
        for (j = 0; j < var2; j++)
        {
            arr[i][j] = var3[i][j];
        }
    return arr;
}

@_stanislav "C with Classes" 1646 / 1403 / 523 Регистрация: 16.08.2014 Сообщений: 5,877 Записей в блоге: 1
	09.03.2018, 09:58	2
	ZlayaLola, у тебя на скрине код другой. не понятно что вызвало твою ошибку, какая функция из твоего кода. 0

	09.03.2018, 11:22