HEAP CORRUPTION DETECTED : 在正常块 () 之后

Question

所以，我定义了模板类，然后尝试重载一些运算符。

 template <typename  T> class Set
    {
    public:
        Set(void);
        Set(Set&);
        ~Set(void);
        bool contains(T elem);
        bool add(T elem);
        bool remove(T elem);
        bool add(T* tab, int size);
        T* getSet();
        int size();
        Set<T> &operator+(Set<T> &snd);
        Set<T> &operator-(Set<T> &snd);
    private:
        T *elements;
        int numOfElem;
    };

当我尝试通过 add 方法向 Set 添加元素时，一切正常。

template<typename T>
    bool Set<T>::add(T elem)
    {
        bool found = false;
        for(int i =0; !found && i<numOfElem; i++){
            if(elem == elements[i]) found = true;
        }
        if( !found ){
            numOfElem++;
            T* tmp = new T[numOfElem];
            for(int i =0;  i<numOfElem-1; i++){
                tmp[i] = elements[i];
            }
            tmp[numOfElem-1] = elem;
            delete[] elements;
            elements = tmp;
        }
        return !found;
    }

    template<typename T>
    bool Set<T>::add(T* myArray, int size)
    {
        bool result = false;
        for(int i =0;  i<size; i++){
            add(myArray[i]);
        }
        return result;
    }
template<typename T> 
Set<T>& Set<T>::operator+(Set<T> &snd)
{
    Set *temp = new Set(*this);
    temp->add(snd.getSet(), snd.size());
    return *temp;
}
template<typename T> 
void Set<T>::operator=(Set<T> &snd)
{
    numOfElem = snd.numOfElem;
    elements = new T[numOfElem];
    for(int i =0; i < numOfElem; i++){
        elements[i] = snd.elements[i];
    }
}

template<typename T>
int Set<T>::size()
{
    return numOfElem;
}
template<typename T> 
T* Set<T>::getSet()
{
    return elements;
}
template<typename T>
Set<T>::Set()
{
  numOfElem = 0;
  elements = nullptr;
}

template<typename T>
Set<T>::Set(Set& old)
{
  numOfElem = old.numOfElem;
  elements = new T(numOfElem);
  for(int i = 0; i< numOfElem; i++){
      elements[i] = old.elements[i];
  }

}

template<typename T>
Set<T>::~Set()
{
  numOfElem = 0;
  delete[] elements;
  elements = nullptr;
}

但如果我改用 + 运算符（添加两个单独的集合），则会在尝试删除数组（15 行）时发生错误。有什么想法吗？

int main(){
    Set <char> set1, set2, set3;
    char tab[] = {'a','d','f','g'} ;
    set1.add(tab, 4);
    char tab2[] = {'a','d','x','y','z'} ;
    set2.add(tab2,5);
    set3= set1+set2;
}

Answer 1

你的复制构造函数有错误：

elements = new T(numOfElem);

应该是

elements = new T[numOfElem];

通过编写new T(numOfElem);，您只分配了一个变量，其值初始化为 numOfEllem。

使用 std::vector 代替数组可以避免此类问题。

您的代码还在加法运算符中泄漏了内存：

template<typename T> 
Set<T>& Set<T>::operator+(Set<T> &snd)
{
    Set *temp = new Set(*this);
    temp->add(snd.getSet(), snd.size());
    return *temp;
}

您正在分配内存并且您永远不会删除它，因此如果您过于频繁地调用该函数，您的程序可能会耗尽其虚拟内存并会因未捕获的 std::bad_alloc 异常而崩溃。把函数改成这样：

template<typename T>
Set<T> Set<T>::operator+(Set<T> &snd)
{
    Set temp(*this);
    temp.add(snd.getSet(), snd.size());
    return temp;
}