Exception _debugbreak() 执行 main() 函数后

Question

这段代码完全正确执行，但是在退出

main()

函数时，抛出异常：

在 program.exe 中执行了断点指令（__debugbreak() 语句或类似的调用）

我理解是使用指针和删除它们有关，但是我找不到这个问题的原因

我尝试用

delete

注释掉一些行，但这并没有改变结果。 DynamicArray.h :

#pragma once

#include <iostream>
#include <cmath>

using namespace std;

template <typename n, typename T>
class DynamicArray {
private:
    T* arr;
    n _size;
    n _capacity;

    void defaultFilling(const n startIndex = n());

public:

    DynamicArray();
    DynamicArray(const n _size);
    DynamicArray(T* _arr, const n _size);
    DynamicArray(const DynamicArray& otherArr);

    ~DynamicArray();

    n size() const;
    n capacity() const;

    void add(const T value);
    void add(const T* _arr, const n _size);
    void add(const DynamicArray<n, T>& otherArr);
    void remove(const T value);
    void removeAll(const T value);
    void remove();
    void removeAt(const n index);

    bool isInArr(const T value);
    n indexOf(const T value);
    n allIndexOf(const T value, n* indexes);
    void clear();

    DynamicArray& operator=(const DynamicArray& otherArr);
    T& operator[](const n index) const;

    class BadDynamicArray;
};

template <typename n, typename T>
ostream& operator<<(ostream& os, const DynamicArray<n, T>& arr);

template <typename n, typename T>
bool operator==(const DynamicArray<n, T>& arr1, const DynamicArray<n, T>& arr2);

template <typename n, typename T>
bool operator!=(const DynamicArray<n, T>& arr1, const DynamicArray<n, T>& arr2);

template <typename n, typename T>
class DynamicArray<n, T>::BadDynamicArray {
public:
    string errorMessage;
    BadDynamicArray(const string& erMsg) : errorMessage(erMsg) {}

    // перевантаження оператора виведення класу помилок
    friend ostream& operator<<(ostream& os, const BadDynamicArray& bArr) {
        os << "\n--Виникла помилка: " << bArr.errorMessage << "--\n";
        return os;
    }
};

template <typename n, typename T>
void DynamicArray<n, T>::defaultFilling(const n startIndex) {
    for (n i = startIndex; i < _capacity; i++) {
        arr[i] = T();
    }
}

template <typename n, typename T>
DynamicArray<n, T>::DynamicArray() {
    this->_size = 0;
    _capacity = 4;
    arr = new T[_capacity];
    defaultFilling();
}

template <typename n, typename T>
DynamicArray<n, T>::DynamicArray(const n _size) {
    if (_size >= 0) {
        this->_size = _size;
        _capacity = _size + pow(4, _size / 10 + 1);
        arr = new T[_capacity];
    }
    else {
        cout << BadDynamicArray("Розмір масиву не може бути від'ємним! Створено масив розміром 0!") << endl;
        this->_size = 0;
        _capacity = 4;
        arr = new T[_capacity];
    }
    defaultFilling();
}

template <typename n, typename T>
DynamicArray<n, T>::DynamicArray(T* _arr, const n _size) {
    if (_size >= 0) {
        this->_size = _size;
        _capacity = _size + pow(4, _size / 10 + 1);
        arr = new T[_capacity];

        for (n i = 0; i < _size; i++) {
            arr[i] = _arr[i];
        }
        defaultFilling(_size);
    }
    else {
        cout << BadDynamicArray("Розмір масиву не може бути від'ємним! Створено масив розміром 0!") << endl;
        this->_size = 0;
        _capacity = 4;
        arr = new T[_capacity];
        defaultFilling();
    }   
}

template <typename n, typename T>
DynamicArray<n, T>::DynamicArray(const DynamicArray& otherArr) {
    *this = otherArr;
}

template <typename n, typename T>
DynamicArray<n, T>::~DynamicArray() {
    delete arr;
}

template <typename n, typename T>
n DynamicArray<n, T>::size() const {
    return _size;
}

template <typename n, typename T>
n DynamicArray<n, T>::capacity() const {
    return _capacity;
}

template <typename n, typename T>
void DynamicArray<n, T>::add(T value) {
    if (_size == _capacity) {
        _capacity += pow(4, _size / 10 + 1);

        T* temp = arr;

        arr = new T[_capacity];
        for (n i = 0; i < _size; i++) {
            arr[i] = temp[i];
        }
        arr[_size] = value;
        _size++;

        defaultFilling(_size);

        delete temp;
    }
    else {
        arr[_size] = value;
        _size++;
    }
}

template <typename n, typename T>
void DynamicArray<n, T>::add(const T* _arr, const n _size) {
    if (this->_size + _size > _capacity) {
        _capacity = this->_size + _size + pow(4, this->_size + _size / 10 + 1);

        T* temp = arr;

        arr = new T[_capacity];
        for (n i = 0; i < this->_size; i++) {
            arr[i] = temp[i];
        }
        
        for (n i = this->_size; i < this->_size + _size; i++) {
            arr[i] = _arr[i - this->_size];
        }

        this->_size += _size;

        defaultFilling(this->_size);

        delete temp;
    }
    else {
        
        for (n i = this->_size; n < this->_size + _size; i++) {
            arr[i] = _arr[i - this->_size];
        }
        this->_size += _size;
    }
}

template <typename n, typename T>
void DynamicArray<n, T>::add(const DynamicArray<n, T>& otherArr) {
    add(otherArr.arr, otherArr._size);
}

template <typename n, typename T>
void DynamicArray<n, T>::remove(const T value) {
    
    for (n i = 0; i < _size; i++) {
        if (arr[i] == value) {
            for (n j = i; j < _size - 1; j++) {
                arr[j] = arr[j + 1];
            }

            _size--;
            break;
        }
    }   
}

template <typename n, typename T>
void DynamicArray<n, T>::removeAll(const T value) {
    for (n i = 0; i < _size; i++) {
        if (arr[i] == value) {
            for (n j = i; j < _size - 1; j++) {
                arr[j] = arr[j + 1];
            }

            i--;
            _size--;
        }
    }
}

template <typename n, typename T>
void DynamicArray<n, T>::remove() {
    _size--;
}

template <typename n, typename T>
void DynamicArray<n, T>::removeAt(const n index) {
    if (index >= 0 && index < _size) {
        for (n i = index; i < _size - 1; i++) {
            arr[i] = arr[i + 1];
        }
        _size--;
    }
}

template <typename n, typename T>
bool DynamicArray<n, T>::isInArr(const T value) {

    for (n i = 0; i < _size; i++) {
        if (arr[i] == value) {
            return true;
        }
    }

    return false;
}

template <typename n, typename T>
n DynamicArray<n, T>::indexOf(const T value){

    for (n i = 0; i < _size; i++) {
        if (arr[i] == value) {
            return i;
        }
    }

    return -1;
}

template <typename n, typename T>
n DynamicArray<n, T>::allIndexOf(const T value, n* indexes) {
    
    if (indexes != nullptr) {
        delete indexes;
    }

    indexes = new n[_size];
    int counter = 0;
    
    for (n i = 0; i < _size; i++) {
        if (arr[i] == value) {
            indexes[counter] = i;
            counter++;
        }
    }

    return counter;
}

template <typename n, typename T>
void DynamicArray<n, T>::clear() {
    _size = 0;
}

template <typename n, typename T>
DynamicArray<n, T>& DynamicArray<n, T>::operator=(const DynamicArray<n, T>& otherArr) {
    _size = otherArr._size;
    _capacity = otherArr._capacity;

    arr = new T[_capacity];

    for (n i = 0; i < _size; i++) {
        arr[i] = otherArr.arr[i];
    }
    defaultFilling(_size);
    return *this;
}

template <typename n, typename T>
T& DynamicArray<n, T>::operator[](const n index) const {

    if (index < 0) {
        cout << BadDynamicArray("Індекс не може бути від'ємним! Повернено значення за індексом 0!") << endl;
    }
    else if (index >= _size) {
        cout << BadDynamicArray("Вихід за межі масиву - індекс повинен бути меншим за його розмір! Повернено значення за індексом 0!") << endl;
    }
    else {
        return arr[index];
    }
    return arr[0];
}

template <typename n, typename T>
ostream& operator<<(ostream& os, const DynamicArray<n, T>& arr) {

    os << "{";
    for (n i = 0; i < arr.size(); i++) {
        os << arr[i];
        if (i < arr.size() - 1) {
            os << ", ";
        }
    }
    os << "}";
    return os;
}

template <typename n, typename T>
bool operator==(const DynamicArray<n, T>& arr1, const DynamicArray<n, T>& arr2) {
    if (arr1.size() == arr2.size()) {

        for (n i = 0; i < arr1.size(); i++) {
            if (arr1[i] != arr2[i]) {
                return false;
            }
        }
        return true;
    }
    return false;
}

template <typename n, typename T>
bool operator!=(const DynamicArray<n, T>& arr1, const DynamicArray<n, T>& arr2) {
    return !(arr1 == arr2);
}

Main.cpp：

#include "DynamicArray.h"
#include <Windows.h>

int main() {
    SetConsoleOutputCP(1251);
    SetConsoleCP(1251);

    DynamicArray<int, string> sequence;

    cout << sequence << endl;

    
    sequence.add("Hello world!");

    cout << sequence << endl;

    
    sequence.add("I'm programming using C++");
    sequence.add("Apple");

    cout << sequence << endl;

    
    sequence.remove("Hello world!");

    cout << sequence << endl;

    
    if (sequence.isInArr("Dog")) {
        cout << "--String belongs to the sequence!--\n";
    }
    else {
        cout << "--String doesn't belongs to the sequence!--\n";
    }

    
    if (sequence.isInArr("Apple")) {
        cout << "--String belongs to the sequence!--\n";
    }
    else {
        cout << "--String doesn't belongs to the sequence!--\n";
    }

    
    sequence.clear();

    cout << sequence << endl;

    return 0;
}