Comment gérer ou éviter un débordement de la pile en C++

En C++ un débordement de pile conduit généralement à une irrémédiable de plantage du programme. Pour les programmes qui doivent être vraiment robuste, c'est un comportement inacceptable, en particulier parce que la taille de la pile est limitée. Quelques questions sur la façon de gérer le problème.

  1. Est-il un moyen pour empêcher le débordement de pile par une technique générale. (Une solution évolutive, robuste solution, qui comprend traiter avec les bibliothèques externes de manger beaucoup de pile, etc.)

  2. Est-il un moyen de gérer les débordements de pile dans le cas où ils se produisent? De préférence, la pile devient déroulé jusqu'à ce qu'il y a un gestionnaire de traiter avec un peu problème.

  3. Il y a des langues, qui ont des fils extensible avec des piles. C'est quelque chose comme que possible en C++?

Tout autres commentaires utiles à la solution du C++ comportement serait appréciée.

  • support.microsoft.com/kb/315937
  • La norme ne mentionne même pas la pile, vous devez spécifier la plate-forme de ciblage; plusieurs plates-formes de fournir des moyens pour intercepter le dépassement de pile ou même d'obtenir un "stack overflow" alerte lorsque la pile est presque épuisée.
  • Personnellement, je trouve qu'un Débordement de Pile n'est pas quelque chose à éviter, mais embrasser. Il suffit de regarder la grande communauté!
  • La seule chose qu'il vaut la peine de regarder est pile "fuites", où d'importantes fonctions ont tendance à s'appellent eux-mêmes (ou d'autres) de manière récursive, qui a entraîné une "accumulation" de programme de l'etat (je n'ai jamais vu cela se produire, et que vous pensez que votre programme serait présentent un grand nombre d'autres tumeurs et des troubles de l'avant c'est devenu évident, mais qui ne rend pas impossible). Peut-être aussi une limite sur toutes les fonctions récursives vous allez utiliser.
  • Version moderne de Beugler de Canard lien? msdn.microsoft.com/en-us/library/89f73td2.aspx
  • L'utilisation d'un smart compilateur: gcc -fsplit-stack, et vous êtes plus susceptibles d'avoir un débordement de pile que vous êtes à court de mémoire.
  • Qu'est-ce compilateur option?
  • Jamais trouvé de débordement de pile à être un problème, (sur OS de bureau, de toute façon). Il est arrivé, bien sûr, mais seulement en raison d'une grave cockup de ma part, facilement et de débogage. En comparaison avec la grande majorité de vraiment méchant de bugs, DONC, est un non-problème.
  • Comme son nom l'indique, divise la pile. L'idée est que vous commencez avec une petite pile et le compilateur instruments de l'exécution de la faire grandir que vous en avez besoin, éventuellement discontiguously (comme l'espace d'adressage de mémoire va). Évidemment, cela peut ralentir le programme un peu, je n'ai pas exactement par qui de marge si. J'ai seulement de la gcc à l'appui de cette option; Clang + LLVM ne fonctionne pas et je n'ai jamais entendu parler de MSVC.
  • Génial. C'est le genre de chose que je cherchais.
  • StackOverflow erreur vient du fait que vous êtes l'allocation de trop grandes variable ou un tableau. Vous allouer plus efficacement que les grandes variable/tableau de tas.

InformationsquelleAutor Ralph Tandetzky | 2012-08-27
  1. 23

    La manipulation d'un débordement de pile n'est pas la bonne solution, au lieu de cela, vous devez vous assurer que votre programme n'a pas de débordement de la pile.

    Ne pas allouer de grandes variables sur la pile (où ce qui est "grand" dépend du programme). Veiller à ce que toute récursif algorithme se termine après qu'une profondeur maximale. Si un algorithme récursif peut répéter un nombre indéterminé de fois ou un grand nombre de fois, soit de gérer la récursivité vous-même (par le maintien de votre propre dynamiquement alloué sur la pile) ou de transformer l'algorithme récursif en équivalent d'un algorithme itératif

    Un programme qui doit être "vraiment robuste" ne pas utiliser un tiers ou à des bibliothèques externes qui "mangent beaucoup de pile."

    Noter que certaines plates-formes de notifier un programme lorsqu'un débordement de pile se produit et que le programme de traitement de l'erreur. Sur Windows, par exemple, une exception est levée. Cette exception n'est pas une des exceptions C++, cependant, il est asynchrone exception. Alors qu'une des exceptions C++ ne peut être levée par un throw déclaration, asynchrone exception peut être levée à tout moment durant l'exécution d'un programme. C'est prévu, bien que, en raison d'un dépassement de pile peut se produire à tout moment: tout appel de fonction ou de l'allocation de pile peut débordement de la pile.

    Le problème est qu'un débordement de la pile peut provoquer une asynchrones exception, même à partir d'un code qui n'est pas prévu de lancer une quelconque des exceptions (par exemple, à partir de fonctions marqué noexcept ou throw() en C++). Donc, même si vous ne gérer cette exception d'une certaine manière, vous n'avez aucun moyen de savoir que votre programme est dans un état de sécurité. Par conséquent, la meilleure façon de gérer asynchrone exception n'est pas à traiter à tous(*). Si l'on est jeté, cela signifie que le programme contient un bogue.

    D'autres plates-formes peuvent avoir les mêmes méthodes pour "manipulation" une erreur de dépassement de pile, mais ces méthodes sont susceptibles de souffrir du même problème: le code qui est censé ne pas causer une erreur peut provoquer une erreur.

    (*) Il y a quelques très rares exceptions.

    • Utilisation de bibliothèques de tiers est souvent une question de coûts. Vous devez utiliser la WinApi, directement ou indirectement, si vous êtes sur Windows dans votre programme à un certain point. Même sur d'autres système. Vous ne serez pas en mesure d'être sans tiers bibliothèques. (Vous pourriez envisager de la norme C++ de la bibliothèque en tant que tierce partie.) Mais mon point est, si vous voulez avoir un super programme solide et utiliser des bibliothèques tierces pour réduire les coûts, alors vous pourriez avoir besoin d'un moyen de garantir que le programme ne plante pas complètement par un débordement de pile dans d'autres bibliothèques.
    • Pouvez-vous nous en dire plus au sujet de ces très rares exceptions"?
    InformationsquelleAutor James McNellis
  2. 7

    Vous pouvez vous protéger contre les débordements de pile à l'aide de bonnes pratiques de programmation, comme:

    1. Être très prudent avec la récursivité, j'ai récemment vu une SORTE résultant de mal écrits récursive CreateDirectory fonction, si vous n'êtes pas sûr si votre code est 100% ok, puis ajouter le gardiennage de la variable qui va arrêter l'exécution après la N des appels récursifs. Ou même mieux de ne pas écrire des fonctions récursives.
    2. Ne pas créer d'énormes tableaux sur la pile, ce qui pourrait être caché des tableaux comme un très grand tableau comme un champ de classe. Il est toujours préférable d'utiliser de vecteur.
    3. Être très prudent avec les alloca, surtout si il est mis dans certaines définition de macro. J'ai vu de nombreux résultant de la conversion de chaîne de macros mettre en pour les boucles qui ont été en utilisant des alloca rapide de l'allocation mémoire.
    4. Assurez-vous que la taille de votre tapis est optimale, ce qui est plus important dans les plateformes embarquées Si vous thread ne fait pas beaucoup, puis il donne un petit tapis, sinon l'utilisation de plus grandes. Je sais que la réservation ne devrait prendre que quelques adresse de gamme - pas de mémoire physique.

    ceux sont les la plupart des causes que j'ai vu dans les dernières années.

    Automatique AFIN de trouver que vous devriez être en mesure de trouver des outils d'analyse de code statique.

    InformationsquelleAutor marcinj
  3. 2

    C++ est un langage puissant, et que la puissance vient de la capacité à se tirer dans le pied. Je ne suis pas au courant de n'importe quel mécanisme de détecter et de corriger/abandonner lors d'un débordement de pile se produit. Certainement une telle détection serait mise en œuvre spécifiques. Par exemple g++ fournit -fstack-protector pour aider à surveiller votre utilisation des piles.

    En général, votre meilleur pari est d'être proactif en évitant les grands basée sur la pile des variables et prudent avec les appels récursifs.

    • -fstack-protector n'est pas de les aider à contrôler l'excès de l'allocation de pile. C'est pour détecter lorsque la pile alloué variables d'écrire en dehors de leurs limites.
    InformationsquelleAutor Mark B
  4. 2

    Re: extensible à piles. Vous pourriez vous donner plus d'espace de pile avec quelque chose comme ceci:

    #include <iostream>

int main()
{
    int sp=0;

    //you probably want this a lot larger
    int *mystack = new int[64*1024];
    int *top = (mystack + 64*1024);

    //Save SP and set SP to our newly created
    //stack frame
    __asm__ ( 
        "mov %%esp,%%eax; mov %%ebx,%%esp":
        "=a"(sp)
        :"b"(top)
        :
        );
    std::cout << "sp=" << sp << std::endl;

    //call bad code here

    //restore old SP so we can return to OS
    __asm__(
        "mov %%eax,%%esp":
        :
        "a"(sp)
        :);

    std::cout << "Done." << std::endl;

    delete [] mystack;
    return 0;
}

    C'est gcc l'assembleur de la syntaxe.

    • Oups, faire que int *top = (mystack + 64*1024 - 1);
    • Probablement également re: assez de puissance pour tirer une balle dans le pied.
    • Ouch! Ce un hack!
    • Je ne pense pas que cela puisse fonctionner. Il serait préférable de push/pop esp que de vivre dans un registre parce que vous ne savez pas si le compilateur va décider d'utiliser eax pour quelque chose.
    InformationsquelleAutor Nathan Andrew Mullenax