表达式_BLOCK_TYPE_IS_VALID(pHead->nBlockUse) 错误

Expression _BLOCK_TYPE_IS_VALID(pHead->nBlockUse) Error

本文关键字：gt nBlockUse 错误 TYPE BLOCK IS VALID 表达式 pHead-      更新时间：2023-10-16

通过引用"_BLOCK_TYPE_IS_VALID(pHead->nBlockUse("添加参数后，调试断言失败。

class Stack
{
private:
    const std::uint32_t m_maxElement;
protected:
    std::uint32_t m_currentElement;
    int *m_tab;
public:
    Stack(std::uint32_t p_maxElement);
    virtual ~Stack();
    void push(int p_element);
    std::int32_t pop(void);
    std::uint32_t size(void) const;
};
Stack::Stack(std::uint32_t p_maxElement) : m_maxElement(p_maxElement), m_tab(new int[m_maxElement]), m_currentElement(0u)
{}
Stack::~Stack()
{
    if (m_tab) delete[] m_tab;
}
void Stack::push(int p_element)
{
    if (m_currentElement < m_maxElement)
    {
        m_tab[m_currentElement] = p_element;
        ++m_currentElement;
    }
}
std::int32_t Stack::pop()
{
    if (m_currentElement > 0u)
    {
        return m_tab[--m_currentElement];
    }
}
std::uint32_t Stack::size() const
{
    return m_currentElement;
}
/*************************************************************************/
std::int32_t median(Stack p_stack)
{
    std::vector<std::int32_t> l_container(p_stack.size());
    while (p_stack.size())
    {
        l_container.push_back(p_stack.pop());
    }
    std::sort(l_container.begin(), l_container.end());
    int l_containerSize = l_container.size();
    int l_middleIndex = l_containerSize / 2;
    if (l_containerSize % 2 == 0)
    {
        int l_firstMiddleElement = l_container[l_middleIndex - 1];
        int l_secondMiddleElement = l_container[l_middleIndex];
        return (l_firstMiddleElement + l_secondMiddleElement) / 2;
    }
    else
    {
        return l_container[l_middleIndex];
    }
    return 0;
}
std::int32_t arithmeticAverage(Stack p_stack)
{
    std::int32_t l_sum = 0;
    int l_stackSize = p_stack.size();
    while (p_stack.size())
    {
        l_sum = p_stack.pop();
    }
    return l_sum / l_stackSize;
}
int main()
{
    Stack firstStack(10);
    firstStack.push(2);
    firstStack.push(4);
    firstStack.push(8);
    std::cout << "firstStack.pop() = " << firstStack.pop() << std::endl;
    std::cout << "median(firstStack) = " << median(firstStack) << std::endl
    std::cout << "arithmeticAverage(firstStack) = " << arithmeticAverage(firstStack) << std::endl;
    return 0;
}

在的情况下

std::int32_t median(Stack &p_stack)

是可以的。而不是std:：int32_t中值(堆栈p_Stack(在出现"_BLOCK_TYPE_IS_VALID(pHead->nBlockUse("行之后。

如果median函数按值取Stack，编译器必须复制原始Stack。因为您没有在Stack中定义复制构造函数，所以编译器生成了自己的复制构造函数，它执行成员复制，这意味着它只复制指针的值，这样Stack的两个实例现在就指向同一内存位。然后，当median函数完成执行时，会调用副本的析构函数并删除内存，因此现在主目录中的原始Stack指向导致错误的已释放块。

当median引用时，不会进行复制——它会引用main中的原始Stack，并且不会调用析构函数。

我建议您更改代码，使median和其他函数以const引用Stack作为参数。

相关文章：