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

vous pouvez vous protéger contre les débordements de pile en utilisant de bonnes pratiques de programmation, comme:

1. soyez très prudent avec la récursion, j'ai récemment vu un SO résultant de la fonction de CreateDirectory récursive mal écrite, si vous n'êtes pas sûr que votre code est correct à 100%, alors ajoutez une variable de garde qui arrêtera l'exécution après N appels récursifs. Ou encore mieux, n'écrivez pas de fonctions récursives.
2. ne créez pas de tableaux énormes sur la pile, cela pourrait être des tableaux cachés comme un très grand tableau comme champ de classe. Il est toujours préférable d'utiliser de vecteur.
3. être très prudent avec alloca, surtout si elle est mise dans une macro définition. J'ai vu si nombreux résultant de macro de conversion de chaîne de caractères mis dans pour des boucles qui utilisaient alloca pour des allocations de mémoire rapides.
4. assurez-vous que la taille de votre pile est optimale, ceci est plus important dans les plateformes embededées. Si vous thread ne fait pas beaucoup, alors donnez - lui une petite pile, sinon utilisez plus grand. Je sais réservation quelques adresse de gamme - pas de mémoire physique.

ce sont les causes les plus fréquentes que j'ai vues ces dernières années.

pour la recherche automatique ainsi vous devriez être en mesure de trouver des outils d'analyse statique de code.

C++ est un langage puissant, et avec ce pouvoir vient la capacité de se tirer dans le pied. Je ne suis pas au courant d'un mécanisme portable pour détecter et corriger/Annuler lorsque le débordement de la pile se produit. Certainement une telle détection serait mise en œuvre spécifiques. Par exemple g++ fournit -fstack-protector pour aider à surveiller l'utilisation de votre pile.

en général, votre meilleur pari est d'être proactif en évitant les grandes variables basées sur la pile et en faisant attention avec les appels récursifs.

Re: stacks extensibles. 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 la syntaxe assembleur de gcc.

#include <iostream>
using **namespace** std;
class Complex
{

 public: double *re, *im;

 Complex()
 {

    re = new double(r);

    im = new double(m);

}

Complex( )
{

    re = new double; 
    im = new double;
    *re = *t.re; 
    *im= *t.im;

}

~Complex()
{

        delete re, im;

}

};

int main() {

double x, y, z;
cin >> x >> y  >> z;
Complex n1(x,y);
cout << *n1.re << "+" << *n1.im << "i ";
Complex n2 = n1;
cout << *n2.re << "+" << *n2.im << "i ";
*n1.im = z;
cout << *n2.re << "+" << *n2.im << "i ";
cout << *n1.re << "+" << *n1.im << "i ";
return 0;
}