C++ 流程返回-对于具有双精度但不具有int的模板，返回1073741819（0xC0000005）

我尝试创建一个动态数组，在数组的开头添加元素。对于int，它工作得很好，但是当我尝试double时，它给了我返回的错误进程-1073741819 0xC0000005。调试它工作得很好，并且都在范围内，但是当我运行它时，它崩溃了

这是标题：

#define DYNAMICARRAY_H
#include <cstddef>

template <class T>
class DynamicArray
{
    public:
        DynamicArray();
        DynamicArray(size_t);
        DynamicArray(const DynamicArray&);
        virtual ~DynamicArray();

        DynamicArray& operator=(const DynamicArray&);
        T &operator[] (size_t);

        void add(T element);
        size_t getCapacity();
        size_t getLength();
        bool isEmpty();
        void print();
        void resizeArr();

    protected:

    private:
        T *arr;
        size_t capacity;
        size_t length;
};
#endif // DYNAMICARRAY_H

这是.cpp

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

template <class T>
DynamicArray<T>::DynamicArray()
{
    length = 0;
    capacity = 1;
    arr = (T*)malloc(capacity * sizeof(arr));
    if(!arr){
        throw std::bad_alloc();
    }

}

template <class T>
DynamicArray<T>::DynamicArray(size_t newSize)
{
    length = 0;
    capacity = newSize;
    arr = (T*)malloc(capacity * sizeof(arr));
    if(!arr){
        throw std::bad_alloc();
    }
}

template <class T>
DynamicArray<T>::~DynamicArray()
{
    delete[] arr;
    delete arr;
    delete &capacity;
    delete &length;
}

template <class T>
DynamicArray<T>::DynamicArray(const DynamicArray& other)
{
    length = other.length;
    capacity = other.capacity;
    arr = (T*)malloc(capacity * sizeof(arr));
    if(!arr){
        throw std::bad_alloc();
    }

    for(size_t i = 0; i < length; i++){
        arr[i] = other.arr[i];
    }

}

template <class T>
DynamicArray<T>& DynamicArray<T>::operator=(const DynamicArray& rhs)
{
    if (this == &rhs){
        return *this;
    }

    delete[] arr;

    length = rhs.length;
    capacity = rhs.capacity;
    arr = (T*)malloc(capacity * sizeof(arr));
    if(!arr){
        throw std::bad_alloc();
    }

    for(size_t i = 0; i < length; i++){
        arr[i] = rhs.arr[i];
    }

    return *this;
}

template <class T>
size_t DynamicArray<T>::getLength()
{
    return length;
}

template <class T>
size_t DynamicArray<T>::getCapacity()
{
    return capacity;
}

template <class T>
bool DynamicArray<T>::isEmpty(){
    return length == 0;
}

template <class T>
T &DynamicArray<T>::operator[] (size_t index)
{
    if(index >= length){
        std::cout << "Array index out of bounds" << "\n";
        exit(0);
    }
    return arr[index];
}

template <class T>
void DynamicArray<T>::add(T element)
{
    if(length >= capacity){
        resizeArr();
    }
    if(!isEmpty()){
        for(size_t i = length; i > 0; i--){
            arr[i] = arr[i-1];
        }
    }

    arr[0] = element;
    length ++;

}

template <class T>
void DynamicArray<T>::print()
{
    if(length == 0){
        std::cout << "The array is empty!";
    }
    else{
        for(size_t i = 0; i < length; i++){
            std::cout << arr[i] << " ";
        }
    }
    std::cout << "\n";
}

template <class T>
void DynamicArray<T>::resizeArr(){
    size_t newCapacity = capacity * 2;
    T *arr2 = (T*)realloc(arr, newCapacity * sizeof(arr));

    if(!arr2){
        std::cout << "Bad memory allocation";
        throw std::bad_alloc();
    }

    arr = arr2;
    capacity = newCapacity;
}

template class DynamicArray<double>;
template class DynamicArray<int>;

主要的

#include "DynamicArray.h"
#include <cstdlib>
#include <time.h>
#include <cstddef>

using namespace std;

int main()
{
    srand (time(NULL));


    DynamicArray<int> d(5);
    int randomInt;
    for(size_t i = 0; i < d.getCapacity(); i++){
        randomInt = rand()% 100;
        d.add(randomInt);
    }

    d.print();


    d.add(5);
    d.add(55);
    d.add(3);
    d.add(33);
    d.add(37);

    d.print();

    delete &d;

    cout << "\n\n";

    DynamicArray<double> d2(5);

    double randomDouble;

    for(size_t i = 0; i < d2.getCapacity() - 3; i++){
        //randomDouble = (double)rand() / ((double)RAND_MAX);
        randomDouble = 0.5f;
        d2.add(randomDouble);
        d2.print();
    }

    d2.print();

    return 0;
}

它在第二次崩溃，因为大体上，我已尝试确保它设置的所有内容都正确，但仍然无法工作：

for(size_t i = 0; i < d2.getCapacity() - 3; i++){
        //randomDouble = (double)rand() / ((double)RAND_MAX);
        randomDouble = 0.5f;
        d2.add(randomDouble);
        d2.print();
    }

您可以传递指向delete[]和delete的指针，这两个指针分别不是从new[]或new返回的。程序的行为未定义。相关语言规则：

[解释删除]

。。。在单对象delete表达式中，delete操作数的值可以是空指针值、指向由以前的新表达式创建的非数组对象的指针，或者指向表示此类对象基类的子对象的指针。如果不是，则行为未定义。在数组删除表达式中，delete操作数的值可以是空指针值，也可以是由上一个数组新表达式生成的指针值。 如果不是，则行为未定义

程序的每个删除表达式都违反此规则

要解决此问题，您必须始终使用分配给malloc、realloc或strdup的空闲内存，使用分配给new的指针使用delete，使用分配给new[]的指针使用delete[]，使用指向非动态对象（如成员变量或具有自动或静态存储持续时间的对象）的指针绝对不释放函数，或无效指针

arr = (T*)malloc(capacity * sizeof(arr));

Sizeofar和sizeofT是一样的，我想这不是你想要的。 这应该是sizeof*arr或sizeofT

除此之外，不要像其他人已经指出的那样将malloc/delete或new/free混用

如果你在做C，使用MalC/C++，如果你在C++中使用NeX/DELLATION/< 使用new会将上述内容更改为

arr = new T[capacity];

---

完全避免整个大小调整。

不要删除指向局部变量的指针，也不要删除类的成员。您可以将malloc与delete结合起来。听起来是个坏主意。使用C++新操作符。也许还可以研究智能指针……似乎有着完全相同的问题。此外，由于使用malloc和free而不是new[]和delete[]，DynamicArray将惨败。此外，赋值运算符存在缺陷。如果malloc返回NULL，则代码周围有一个无效的zombie对象；是在复制构造函数中出现问题，还是我根本不应该使用delete[]arr？我试过freearr，但还是不行work@DonVladster您的程序可能比这个程序有更多的错误。@eerorika谢谢！这是一个使用malloc/delete的问题，另一个是错误的！我将检查其他问题的代码要解决这个问题，您必须始终使用分配给malloc的空闲内存-问题是如果std:：string或基本上任何非平凡类型用于T。那么malloc和free将导致其他问题。是的，谢谢，这是混合malloc/delete和new/free的问题。现在可以了！：除了混合malloc/delete之外，代码中还有更多的问题@eerorika已经指出删除未分配元素，或者双重删除arr.@DonVladster警告：您的代码。这意味着它看起来可以工作，但实际上不行。请看。

arr = new T[capacity];