进程返回了 -1073741819 (0xC0000005) 的模板，带有 double 但不是 int

Question

我试图制作一个在数组开头添加元素的动态数组。 它与 int 一起工作得很好，但是当我尝试 double 时，它给了我错误 Process returned -1073741819 (0xC0000005)。 调试它工作得很好，一切都在范围内，但是当我运行它时它崩溃了。

这是 header：

#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();
    }

Answer 1

 arr = (T*)malloc(capacity * sizeof(arr)); delete[] arr; delete arr; delete &capacity; delete &length; delete &d;

您将指针传递给delete[]和delete ，它们分别不是从new[]或new返回的。 程序的行为未定义。 相关语言规则：

[expr.delete]

...在单对象删除表达式中，删除操作数的值可以是 null 指针值，指向由先前的 new 表达式创建的非数组 object 的指针，或指向表示基的子对象的指针object 的 class。 如果不是，则行为未定义。 在数组删除表达式中，删除操作数的值可以是 null 指针值或由前一个数组 new 表达式产生的指针值。 如果不是，则行为未定义。 ...

程序的每个delete表达式都违反了这条规则。

要解决此问题，您必须始终在分配有malloc 、 realloc或strdup new[] memory 上使用free ，并将delete与分配有new delete[]指针一起使用例如具有自动或 static 存储持续时间的成员变量或对象（或无效指针）。

Answer 2

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

sizeof(arr)与sizeof(T*)相同，我想这不是你想要的。 这应该是sizeof(*arr)或sizeof(T) 。

---

除此之外，不要混合malloc/delete或new/free ，正如其他人已经指出的那样。

如果你在做 C，使用malloc/free ，如果你在 C++ 使用new/delete 。

使用new会将上述内容更改为

arr = new T[capacity];

完全避免整个尺寸。