我的内存泄漏在哪里？

Question

所以我写了一个ArrayList（又名C++中的向量）的自己的实现，并且包含了几个算法。现在我的合并排序方法似乎在泄漏内存，但我已逐行检查代码，将分配跟踪到删除，并且这一切似乎都很顺利！

我要指出，我有一个测试脚本为ArrayList中的每个方法和我正在崩溃，然后我试图消除归并测试和繁荣，没有更多的崩溃。但有趣的是......它并不总是崩溃，它有时会起作用，并且会使其他人崩溃。

两个方法中的代码如下：

快速可变枚举：

阵列=那个备份该ArrayList

尺寸数组=，保持的尺寸的轨道的int阵列。

排序=一个布尔值，表示如果列表检查它是否j < size1前整理

/** 
* Runs merge sort on this ArrayList<T>. Interface function to the central, 
* recursive, merge sort function. 
* 
* Runs in O(nlogn) time. However it consumes extra memory. 
*/ 
template<class T> 
void ArrayList<T>::mergeSort() { 

    T* temp = mergeSort(array, size); 
    delete [] array; 
    array = temp; 
    sorted = true; 
} 

/** 
* Runs merge sort on the passed in array. Recursive. 
* 
* Runs in O(nlogn) time. However it consumes extra memory. 
* 
* @param array the array to sort. 
* @param arraySize the size of the array that is to be sorted. 
* @return the sorted array. 
*/ 
template<class T> 
T* ArrayList<T>::mergeSort(T* array, int arraySize) { 

    T* returnArray; 

    //If the array is more than one element. 
    if (arraySize > 1) { 

     int size1 = arraySize/2; 
     int size2 = arraySize - size1; 

     T* array1; 
     T* array2; 

     //Recurse. 
     array1 = mergeSort(array, size1); 
     array2 = mergeSort(array + size1, size2); 

     //Allocate memory for return array. 
     returnArray = new T[arraySize]; 

     //Loop through all elements in returnArray. 
     int i = 0, j = 0, k = 0; 
     while (i < arraySize) { 

      //Place the lesser of two elements in returnArray. 
      if ((array1[j] <= array2[k] && j < size1) 
        || k == size2) { 

       returnArray[i] = array1[j]; 
       j++; 
      } 
      else { 

       returnArray[i] = array2[k]; 
       k++; 
      } 

      i++; 
     } 

     //Free the memory allocated in the recursive calls. 

     delete [] array1; 
     delete [] array2; 
     array1 = 0; 
     array2 = 0; 
    } 
    //If one element is in the passed array. 
    else { 

     //Allocate memory for new array, and assign passed value to it. 
     //This is done so delete can be called in the calling function. 
     returnArray = new T[1]; 
     returnArray[0] = array[0]; 
    } 

    return returnArray; 
} 

Answer 1

您正在访问array1 [ j ]。如果j >= size1那么访问该索引处的数组是非法的。它可能不会总是崩溃，这取决于堆中的内存布局，但它有时会崩溃。您的支票应该是这样的：

if (((j < size1) && (array1[j] <= array2[k])) || k == size2) { 
...