Question

我正在编写一个数组类模板但是在析构函数方面遇到了麻烦。

#ifndef ARRAY_CPP
#define ARRAY_CPP
using namespace std;
#include<iostream>
#include<sstream>
#include "Array.h"


//Define default constructor, initialize an array of size 10 with all elements being (0,0)
template<typename T> //Define type parameter
Array<T>::Array() {
    size = 10;
    m_data = new T[size];
}


template<typename T> //Define type parameter
Array<T>::Array(int si) {
    size = si;
    m_data = new T[size];
}

template<typename T> //Define type parameter
Array<T>::Array(const Array<T>& source) {
    size = source.size; //Set the size equal to the size of the source
    m_data = new T[size]; //Create a new source on the heap
    //Loop through and copy each member of the source array to the new array
    for (int i = 0; i < size; i++) {
        m_data [i] = source.m_data [i];
    }
}

//Define default destructor
template<typename T> //Define type parameter
Array<T>::~Array() {
        delete[] m_data;
    }

    //Define operator =
template<typename T> //Define type parameter
Array<T>& Array<T>::operator = (const Array<T>& source) {
    //Check self-assignment
    if (this != &source) {
        //Delete the old array
        delete[] m_data;
        size = source.size; //Set the size equal to the size of the source
        m_data = source.m_data; //Set the dynamic C array equal to that of the source
        //Loop through each element and copy each member of the source array to the current array
        for (int i = 0; i < size; i++) {
            m_data[i] = source.m_data [i];

        }
    }
    //Return current array
    return *this;

}
//Define operator[]
template<typename T> //Define type parameter
T& Array<T>::operator[](int index) {
    if ((index < 0) || (index>= size))
        throw -1;
    return m_data[index];
}

//Define constant operator[]
template<typename T> //Define type parameter
const T& Array<T>::operator [] (int index) const {
    if ((index < 0) || (index >= size))
        throw -1;
    return m_data[index];
}

using namespace std;
#include<iostream>
#include<sstream>
#include "Array.cpp"


void main() {

    Array<double> test(10);
    Array<double> test2(10);
    test2 = test;
}

每当在main中调用数组的析构函数时，它都会给出错误：为RtlValidateHeap指定的地址无效。我明白这是因为我试图删除堆栈上的内存。但是，在我的构造函数中，我使用new初始化数组，这应该在堆上创建内存...代码在我实现模板之前运行良好。非常感谢提前！

Answer 1

我可以看到一个错误和一个潜在错误：

错误：在赋值运算符中。您复制指针值。

template<typename T>
Array<T>& Array<T>::operator = (const Array<T>& source) {
        // STUFF

        // This is a problem
        m_data = source.m_data;

        // MORE STUFF
    }
    return *this;

}

现在有两个对象指向同一个动态分配的内存。这是一个问题，因为当它们超出范围时，两个对象中的析构函数将尝试在同一指针值上调用delete。

潜在错误：我没有看到复制构造函数。如果您没有定义一个（或者没有明确删除它），编译器将为您生成它。默认值不适用于拥有的资源（即动态分配的内存），因为它是资源的浅表副本。

编译器生成的如下所示：

template<typename T>
Array<T>& Array<T>::Array(const Array<T>& source)
    : size(source.size)
    , m_data(source.m_data)
{}

您可以看到这与您的赋值运算符具有相同的问题。它只是复制指针值。导致同一个问题的两个对象指向同一个动态分配的内存。

在析构函数中使用delete []：为RtlValidateHeap指定的地址无效

1 个答案: