Question

通过引用添加参数“_BLOCK_TYPE_IS_VALID（pHead-＆gt; 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 median（Stack p_stack）在该行之后出现“_BLOCK_TYPE_IS_VALID（pHead-＆gt; nBlockUse）”。

Answer 1

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

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

我建议您更改代码，以便median和另一个函数将const引用Stack作为参数。

表达式_BLOCK_TYPE_IS_VALID（pHead-＆gt; nBlockUse）错误

1 个答案: