C ++堆损坏，但仅在单元测试项目中

Question

我正在使用模板实现自定义堆栈。但是我遇到了一个让我质疑内存安全的问题。析构函数在正常使用时工作正常，但在单元测试时会触发堆损坏。特别是在期望抛出异常的测试上。

所有堆栈代码。

#pragma once
#include "StackOverflowException.h"
#include "StackEmptyException.h"

template <class T>
class Stack
{
public:
    const static int MAX_SIZE = 1000;

    Stack() : m_array(new T[MAX_SIZE]), m_size(0), m_top(0) {};
    Stack(const Stack<T>& _other)
    {
        m_array = new T[MAX_SIZE];
        for(auto i = 0; i < _other.size(); ++i)
        {
            m_array[i] = _other.m_array[i];
        }
        m_size = _other.size();
        m_top = _other.m_top;
    }

    ~Stack()
    {
        delete[] m_array;
    }

    void push(T _item)
    {
        if (m_size + 1 == MAX_SIZE + 1)
        {
            throw StackOverflowException();
        }
        m_array[++m_top] = _item;
        ++m_size;
    }

    T pop()
    {
        if(m_top != 0)
        {
            --m_size;
            T item =  m_array[m_top];
            --m_top;
            return item;
        }
        throw StackEmptyException();
    }

    T peek() const
    {
        if (m_size == 0) throw StackEmptyException();
        T item = m_array[m_top];
        return item;
    }

    bool empty() const
    {
        return m_size == 0;
    }

    size_t size() const
    {
        return m_size;
    }
private:
    T* m_array;
    size_t m_size;
    int m_top;
};

导致堆损坏的单元测试。

        TEST_METHOD(CustomStackPopException)
        {
            Stack<int> stack;
            Assert::ExpectException<StackEmptyException>([&] { stack.pop(); });
        }

        TEST_METHOD(CustomStackPeekException)
        {
            Stack<int> stack;
            Assert::ExpectException<StackEmptyException>([&] { int a = stack.peek(); });
        }

        TEST_METHOD(CustomStackOverflowException)
        {
            Stack<int> stack;
            const auto functor = [&]
            {
                for(auto i = 0; i <= Stack<int>::MAX_SIZE; ++i)
                {
                    stack.push(i);
                }
            };
            Assert::ExpectException<StackOverflowException>(functor);
        }

当它到达第一个测试时，它会弹出一个警告说：

HEAP CORRUPTION DETECTED: after Normal block(#279) at 0x0000020298CBC60.
CRT detected that the application wrote to memory after end of heap buffer.

我尝试在堆上创建堆栈对象，但这会导致同样的错误。

Answer 1

这个成员函数

void push(T _item)
{
    if (m_size + 1 == MAX_SIZE + 1)
    {
        throw StackOverflowException();
    }
    m_array[++m_top] = _item;
    ++m_size;
}

已经不正确。假设 MAX_SIZE 等于 1，m_size 等于 0。在这种情况下，m_size + 1 不等于 MAX_SIZE + 1 并且有 writtem

    m_array[1] = _item;

在分配的数组之外。

编辑：按照以下方式更改方法后

  void push(T _item)
    {
        if (m_size + 1 > MAX_SIZE)
        {
            throw StackOverflowException();
        }
        m_array[++m_top] = _item;
        ++m_size;
    }

在我指出它的问题后，实际上该方法也有同样的问题。事实上，你什么都没有。

你的堆栈也没有用索引 0 填充项目。所以在构造函数中

Stack(const Stack<T>& _other)
{
    m_array = new T[MAX_SIZE];
    for(auto i = 0; i < _other.size(); ++i)
    {
        m_array[i] = _other.m_array[i];
    }
    m_size = _other.size();
    m_top = _other.m_top;
}

在位置 0 处存在对具有不确定值的项的访问

成员函数push应该这样定义

void push( const T &_item)
{
    if (m_size == MAX_SIZE)
    {
        throw StackOverflowException();
    }
    m_array[m_top++] = _item;
    ++m_size;
}

其他成员函数要根据成员函数push来改变。

Answer 2

感谢用户的组合，问题已得到解决。是 push 函数导致了错误。

推送功能改自：

  void push(T _item)
    {
        if (m_size + 1 == MAX_SIZE + 1)
        {
            throw StackOverflowException();
        }
        m_array[++m_top] = _item;
        ++m_size;
    }

收件人：

    void push(T _item)
    {
        if (m_size == MAX_SIZE)
        {
            throw StackOverflowException();
        }
        m_array[m_size] = _item;
        ++m_size;
        ++m_top;
    }

构造函数已更改为：

    Stack() : m_array(new T[MAX_SIZE]), m_size(0), m_top(0) {};

到

    Stack() : m_array(new T[MAX_SIZE]), m_size(0), m_top(-1) {};

现在size和top已经不一样了，m_top实际上指向了栈顶。

Answer 3

使用分配号

HEAP CORRUPTION DETECTED: after Normal block(#279) at 0x0000020298CBC60.
CRT detected that the application wrote to memory after end of heap buffer.

然后在某处启动插入

_CrtSetBreakAlloc(279);

这将向您显示内存分配的位置，并且应该提供有关损坏位置的重要提示。

为什么要自己动手卷？

不要自己实现stack

STL 已经有了那个容器

template <class T>
using my_stack = std::stack< T, std::vector<T> >;