C ++中递归期间的堆栈溢出

Question

我为单链表编写了一个模板类。为了以相反的顺序打印值，我使用递归实现了 traverse_reverse() 函数。当 list 中的元素数量接近 4000 时，调用该函数会引发堆栈溢出错误。 在这样的数字范围内，我不确定是否应该发生堆栈溢出。

环境为 Visual Studio 2019 社区版，Windows 10 64 位操作系统。

我的问题是：

1. 如何避免堆栈溢出

2. 如何在运行时增加堆栈大小。

下面是sn-p的代码：

#pragma once
#include <mutex>
#include <iostream>

namespace MyDS
{
    template <typename T>
    struct Node
    {
        T* m_pData = nullptr;
        Node* m_pNext = nullptr;
    };

    template <class T>
    class sList
    {
        Node<T>* m_pHead = nullptr;
        Node<T>* m_pCurrentNode = nullptr;
        int m_Size = 0;
        std::mutex m_ListMutex;

    public:
        bool insert_front(T val);
        bool insert_last(T val);
        bool insert_anywhere(T val, int loc);

        bool remove(T val);
        //bool remove(int loc);
        bool remove_front();
        bool remove_last();

        void traverse();
        void traverse_reverse();

        bool emptyList();

        int getSize();

    private:
        void traverse_reverse(Node<T>* pNode);
    };

    template<typename T>
    void sList<T>::traverse_reverse(Node<T>* pNode)
    {
        if (pNode->m_pNext != nullptr)
            traverse_reverse(pNode->m_pNext);
        std::cout << *pNode->m_pData << " ";
    }

    template<typename T>
    bool sList<T>::emptyList()
    {
        bool ret = false;
        if (getSize() > 0)
        {
            std::lock_guard<std::mutex> lg(m_ListMutex);

            Node<T>* pTempNode = m_pHead, pTempNode1 = nullptr;
            while (pTempNode->m_pNext!= nullptr)
            {
                pTempNode1 = pTempNode->m_pNext;

                delete pTempNode->m_pData;
                delete pTempNode;
                pTempNode = pTempNode1;
            }

            delete pTempNode->m_pData;
            delete pTempNode;

            pTempNode->m_pData = pTempNode1->m_pData = m_pHead->m_pData = m_pCurrentNode->m_pData = nullptr;
            pTempNode = pTempNode1 = m_pHead = m_pCurrentNode = nullptr;
            m_Size = 0;
        }

        ret = true;
        return ret;
    }

    template<typename T>
    int sList<T>::getSize()
    {
        return m_Size;
    }

    template<typename T>
    bool sList<T>::insert_front(T val)
    {
        Node<T>* pNode = new Node<T>;
        pNode->m_pData = new T(val);

        if (getSize() > 0)
        {
            pNode->m_pNext = m_pHead;
        }

        m_pHead = pNode;
        m_Size++;

        return true;
    }


    template<typename T>
    bool sList<T>::insert_last(T val)
    {
        Node<T>* plastNode = m_pHead;
        while (plastNode->m_pNext!= nullptr)
            plastNode = plastNode->m_pNext;

        plastNode->m_pNext = new Node<T>;
        plastNode->m_pNext->m_pData = new T(val);

        return true;
    }


    template<typename T>
    bool sList<T>::insert_anywhere(T val, int loc)
    {
        return true;
    }


    //template<typename T>
    //bool sList<T>::remove(int loc)
    //{
    //  return true;
    //}


    template<typename T>
    bool sList<T>::remove_front()
    {
        std::lock_guard<std::mutex> lg(m_ListMutex);
        Node<T>* pNode = m_pHead;
        m_pHead = m_pHead->m_pNext;

        delete pNode->m_pData;
        delete pNode;

        m_Size--;
        return true;
    }

    template<typename T>
    bool sList<T>::remove_last()
    {
        Node<T>* plastNode = m_pHead;
        std::lock_guard<std::mutex> lg(m_ListMutex);
        if (getSize() > 1)
        {
            while (plastNode->m_pNext->m_pNext != nullptr)
                plastNode = plastNode->m_pNext;

            Node<T>* pNode = plastNode->m_pNext;
            plastNode->m_pNext = nullptr;

            delete pNode->m_pData;
            delete pNode;
            pNode->m_pData = pNode = nullptr;
            m_Size--;
        }
        else if(getSize() == 1) // Only 1 node 
        {
            delete m_pHead->m_pData;
            delete m_pHead;

            m_pHead->m_pData = m_pHead = nullptr;
            m_Size--;
        }
        else   // No node available
        {
            //Nothing to do 
        }

        return true;

    }

    template<typename T>
    bool sList<T>::remove(T val)
    {
        bool ret = false;
        Node<T>* pNode = m_pHead;
        Node<T>* pNodeNext = pNode->m_pNext;

        if (pNode->m_pData == val)
        {
            ret = remove_front();
        }
        else if (pNodeNext->m_pData == val)
        {
            pNode->m_pNext = pNodeNext->m_pNext;
            pNodeNext->m_pNext = nullptr;

            delete pNodeNext->m_pData;
            delete pNodeNext;
            pNodeNext->m_pData = pNodeNext = nullptr;
            ret = true;
            m_Size--;
        }
        else
        {
            while (pNodeNext->m_pData != val)
            {
                pNode = pNodeNext;
                pNodeNext = pNodeNext->m_pNext;
            }

            if (pNodeNext == nullptr)
                ret = false;
            else
            {
                pNode->m_pNext = pNodeNext->m_pNext;
                pNodeNext->m_pNext = nullptr;

                delete pNodeNext->m_pData;
                delete pNodeNext;
                pNodeNext->m_pData = pNodeNext = nullptr;
                m_Size--;
                ret = true;
            }
        }

        return ret;
    }

    template<typename T>
    void sList<T>::traverse()
    {
        m_pCurrentNode = m_pHead;
        while (m_pCurrentNode->m_pNext != nullptr)
        {
            std::cout << *m_pCurrentNode->m_pData<<" ";
            m_pCurrentNode = m_pCurrentNode->m_pNext;
        }

        std::cout << *m_pCurrentNode->m_pData;
        std::cout << std::endl;
    }

    template<typename T>
    void sList<T>::traverse_reverse()
    {
        m_pCurrentNode = m_pHead;
        traverse_reverse(m_pCurrentNode);
        std::cout << std::endl;
    }

}

#include "MyDS.h"

int main()
{
    MyDS::sList<int> myList;
    for(int i = 0; i <= 3987; ++i)
        myList.insert_front(i);

    myList.traverse_reverse(); //Recursion

//  myList.traverse();
    return 0;
}

Answer 1

正如其他答案所指出的，您没有提供完整的代码。也就是说，从您给出的代码中猜测，我认为问题在于当元素列表足够长时，由于堆栈上的函数调用过多而发生堆栈溢出是正确的。

一般来说，最好避免在堆栈上进行大量的函数调用。增加堆栈大小通常不是一个好的解决方案。例如，请参阅 why is stack memory size so limited? 以了解有关此主题的一些讨论。

单链表可能很难注册。这。一种选择可能是反转单链表（可能创建一个新的单链表），然后只遍历那个单链表（之后可能删除创建的列表）。双链表可以非常轻松有效地做到这一点，因为您可以找到最后一个元素，然后从那里向后退。

Answer 2

如果您想避免堆栈溢出，请不要使用递归。一个简单的while 可以完成相同的工作，而无需从堆栈中获取更多资源：

template<typename T>
void sList<T>::traverse_reverse(Node<T>* pNode)
{
    while (pNode != nullptr){
        std::cout << *pNode->m_pData << " ";
        pNode=pNode->m_pNext;
    }
}  

增加堆栈大小：Increase stack size in c++

但是，如果上述代码不起作用，我怀疑您的问题出在其他地方。我最初的猜测是你有一个无限循环（递归）。假设由于某种原因，您的列表中有循环依赖项：每个节点都有他的m_pNext 填充除nullptr 之外的其他内容。递归永远不会结束，因此 stackoverflow 错误。上面的代码不起作用。

循环依赖通常是由插入或删除方法的错误实现引起的。如果由于某种原因您将删除中的指针错误地更新到另一个节点，则可能会导致循环依赖。

您可以使用以下代码检查循环依赖：

template<typename T>
void sList<T>::traverse_reverse(Node<T>* pNode)
{
    Node<T>* org_p=pNode;
    while (pNode->m_pNext != nullptr){
        pNode=pNode->m_pNext;
        if(org_p==pNode){
            std::cout << "Circular Dependency";
            break;            
        }
    }
    std::cout << "No Circular Dependency";
}  

Answer 3

为了以相反的顺序打印值，我使用递归实现了 traverse_reverse() 函数。

递归（除非您的编译器将optimized 称为tail-recursive calls）总是消耗call stack 空间。另请参阅this draft 报告以获取有趣的GCC 优化示例。可能您的 C++ 编译器能够进行类似的优化。

您可能更喜欢消耗堆空间，例如使用中间标准C++ containers 保存临时数据。

您可能对continuation-passing style 感兴趣。有时它可以让你避免递归（并使用更多的heap memory）。

您可以找到 C++ 实现（想到最近的 GCC 或 Clang...），其源代码 std::vector 或 std::list 是 open source 并且可读。您可能会对它们的复杂性感到惊讶，与rule of five 相关。

如果您使用最近的 GCC 编译您的 C++ 代码，您可以将 used g++ -Wall -Wextra -g -fstack-protector -Wstack-usage=2048 与 -O2 结合使用，以警告大型调用帧。

您可能对 Frama-C++、Coverity、Clang static analyzer 或 address sanitizer 等静态源程序分析工具感兴趣，或者对编写自己的 GCC plugin 来构建调用图和 感兴趣有时检测潜在的堆栈溢出（但请注意Rice's theorem）。另见valgrind。