我错过了什么，导致内存泄漏的原因 C++

Question

I'm having problem understanding where my memory leak is located in my project. The template I have built looks like this:

#pragma once
#include "IHeap.h"
#include <iostream>

using namespace std;

template <typename T>
class dHeap
{
public:
    dHeap(T size);
    dHeap(T size, int nr);
    dHeap(const dHeap &original);
    ~dHeap();
    dHeap<T>& operator=(const dHeap<T> &original);

    void deepCopy(const dHeap &original);
    void push(const T &item);
    T pop();
    T peek()const;
    int size()const;
    int getdValue()const;
    void printAll()const;

    void heapify(int arr[], int size, int root);
    void heapSort(int arr[], int size);

private:
    //T nr;
    T *arrHeap;
    T nrOfItems;
    T capacity;
    T dValue;

    void expandHeap();
};

template<typename T>
inline dHeap<T>::dHeap(T size)
{
    capacity = size;
    arrHeap = new T[capacity + 1];
    nrOfItems = 0;
    dValue = size;

}

template<typename T>
inline dHeap<T>::dHeap(T size, int nr)
{
    capacity = size;
    arrHeap = new T[nr];
    nrOfItems = 0;
    dValue = size;
}

template<typename T>
inline dHeap<T>::dHeap(const dHeap &original)
{
    this->deepCopy(original);
}

template<typename T>
inline dHeap<T>::~dHeap()
{
    delete[] arrHeap;
}

template<typename T>
inline dHeap<T>& dHeap<T>::operator=(const dHeap<T>& original)
{
    if (this != &original)
    {
        this->deepCopy(original);
    }
    return *this;
}

template<typename T>
inline void dHeap<T>::expandHeap()
{
    capacity *= 2;
    T *temp = new T[capacity];

    for (int i = 0; i < nrOfItems; i++)
    {
        temp[i] = arrHeap[i];
    }   

    delete[] arrHeap;
    arrHeap = temp;
}

template<typename T>
inline void dHeap<T>::deepCopy(const dHeap &original)
{
    capacity = original.capacity;
    nrOfItems = original.nrOfItems;
    arrHeap = new T[capacity];
    dValue = original.dValue;

    for (int i = 0; i < original.nrOfItems; i++)
    {
        this->arrHeap[i] = original.arrHeap[i];
    }
}

template<typename T>
inline void dHeap<T>::push(const T &item)
{
    if (nrOfItems >= capacity)
    {
        expandHeap();
    }

    arrHeap[nrOfItems] = item;
    nrOfItems++;
}

template<typename T>
inline T dHeap<T>::pop()
{
    int removed = arrHeap[0];
    arrHeap[0] = arrHeap[nrOfItems - 1];

    nrOfItems--;

    return removed;
}

template<typename T>
inline T dHeap<T>::peek() const
{
    return arrHeap[0];
}

template<typename T>
inline int dHeap<T>::size() const
{
    return this->nrOfItems;
}

template<typename T>
inline int dHeap<T>::getdValue() const
{
    return this->dValue;
}

template<typename T>
inline void dHeap<T>::printAll() const
{
    for (int i = 0; i < nrOfItems; i++)
    {
        cout << "Heap element " << i << ". " << arrHeap[i] << endl;
    }
}

template<typename T>
inline void dHeap<T>::heapSort(int arr[], int size)
{
    for (int j = 0; j < size; j++)
    {
        // Build heap - which means rearrange array
        for (int i = size / 2 - 1; i >= 0; i--)
        {
            heapify(arrHeap, size, i);
        }

        for (int i = size - 1; i >= 0; i--)
        {
            swap(arrHeap[0], arrHeap[i]);
            heapify(arrHeap, i, 0);
        }

        //when re-structured heap, use pop and re-do it again until done
        arr[j] = pop();
    }
}
template<typename T>
inline void dHeap<T>::heapify(int arr[], int n, int root)
{
    int largest = root;  
    int leftChild = 2 * root + 1;
    int rightChild = 2 * root + 2;

    // If left child is larger than root
    if (leftChild < n && arr[leftChild] > arr[largest])
    {
        largest = leftChild;
    }

    // If right child is larger than largest so far
    if (rightChild < n && arr[rightChild] > arr[largest])
    {
        largest = rightChild;
    }

    // If largest is not root, heapify recursivly until done
    if (largest != root)
    {
        swap(arr[root], arr[largest]);
        heapify(arr, n, largest);
    }
}

I have a pointer called heapArr which I use to build up a heap. When the program terminates the destructor is called and there have I put a delete[] this->heapArr declaration to remove the pointer when program is done. And I have also added a delete[] this->heapArr in the expand function in order to free the memory before allocation the new expanded array.

I'm not sure I explained this perfectly but the problem is that I seem to miss to remove something because I get a memory leak warning when I end the program. What have I missed?

Answer 1

Memory leaks in deepCopy , where you allocate new memory without de-allocating the old.

That being said, don't allocate memory yourself. A good chunk of your code is duplicating the functionality of std::vector , so use std::vector<T> instead of T* . (If for some reason you cannot use std::vector I would recommend you implement a replacement. Divide-and-conquer by splitting memory management from the heap logic.)