क्या आप सी ++ में स्टैक ओवरफ़्लो का उदाहरण दे सकते हैं?

Question

क्या आप सी ++ में स्टैक ओवरफ़्लो का उदाहरण दे सकते हैं? रिकर्सिव केस के अलावा:

void foo() { foo(); } 

Answer 1

सामान्य मामला जिसमें अनंत रिकर्सन शामिल नहीं है, वह स्टैक पर एक स्वचालित चर घोषित कर रहा है जो बहुत बड़ा है। उदाहरण के लिए:

int foo() 
{ 
    int array[1000000]; 

} 

Answer 2

कृपया Stack overflow - Wikipedia देखें। मैंने सीधे उदाहरण अनुभाग से लिंक किया है।

Answer 3

void function() 
{ 
function(); 
} 

Answer 4

यह उदाहरण अनियंत्रित रिकर्सन दिखाता है। अंत में, ढेर इस प्रक्रिया को पूरी तरह से बार और सेवानिवृत्त के उदाहरण द्वारा ओवरराइट किया जाएगा करने के लिए आवंटित स्थान दिया गया है ...

int foo(int bar) 
{ 
    int ret = foo(42); 
    return ret; 
} 

Answer 5

रखें मुख्य वापस जाने के लिए जब तक ढेर बाहर चलाता है की कोशिश कर रहा?

int main(int argc, char **argv) 
{ 
    return main(argc, argv); 
} 

Answer 6

अनंत प्रत्यावर्तन:

 
void infiniteFunction() 
{ 
    infiniteFunction(); 
} 

int main() 
{ 
    infiniteFunction(); 
    return 0; 
} 

Answer 7

यहाँ एक है कि व्यवहार में हो सकता है:

int factorial(int x) { 
    return x == 0 ? 1 : x * factorial(x-1); 
} 

यह नकारात्मक x के लिए ढेर overflows। और, as Frank Krueger mentioned, बहुत बड़े x के लिए भी (लेकिन फिर int पहले ओवरफ़्लो होगा)।

Answer 8

प्रति संपादित के रूप में :-)

void ping() 
{ 
    pong(); 
} 

void pong() 
{ 
ping(); 
} 

इसके अलावा, मेरा मानना ​​है कि यदि आप अधिकतम धागा ढेर आकार (वी.एस. में डिफ़ॉल्ट रूप से 1MB) की तुलना में अधिक स्थान आवंटित करने के लिए प्रयास करते समय आपको ढेर अतिप्रवाह प्राप्त कर सकते हैं, तो int a[100000]; कुछ की तरह अपवाद प्रदान करना चाहिए।

Answer 9

मुझे विश्वास नहीं है कि हमने हर समय का सबसे बड़ा रिकर्सन उदाहरण छोड़ दिया है, फैक्टोरियल!

#include <stdio.h> 

double fact(double n) { 
    if (n <= 0) return 1; 
    else return n * fact(n - 1); 
} 

int main() { 
    printf("fact(5) = %g\n", fact(5)); 
    printf("fact(10) = %g\n", fact(10)); 
    printf("fact(100) = %g\n", fact(100)); 
    printf("fact(1000) = %g\n", fact(1000)); 
    printf("fact(1000000) = %g\n", fact(1000000)); 
} 

जीसीसी 4.0.1 के साथ ओएस एक्स 10.5.8 पर:

$ gcc f.c -o f && ./f 
fact(5) = 120 
fact(10) = 3.6288e+06 
fact(100) = 9.33262e+157 
fact(1000) = inf 
Segmentation fault 

दुर्भाग्य से, ओएस एक्स के लिए एक "ढेर अतिप्रवाह" के एक "विभाजन गलती" के बजाय रिपोर्ट। बहुत बुरा।

Answer 10

यदि आप बड़े ऑब्जेक्ट को स्टैक (बाय-वैल्यू) पर रखने की कोशिश करते हैं तो आप एक स्टैक ओवरफ़्लो भी प्राप्त कर सकते हैं।

Answer 11

आप समारोह से एक ढेर अतिप्रवाह में परिणाम की एक स्पष्ट गैर पुनरावर्ती कार्यक्रम जनरेट करना चाहते हैं कॉल:

#!/usr/bin/env python 
import sys 

print "void func" + sys.argv[1] + "() { }" 
for i in xrange(int(sys.argv[1])-1, -1, -1): 
    print "void func" + str(i) + "() { func" + str(i+1) + "(); }" 
print "int main() { func0(); return 0; }" 

नमूना उत्पादन:

$ python recursion.py 5 
void func5() { } 
void func4() { func5(); } 
void func3() { func4(); } 
void func2() { func3(); } 
void func1() { func2(); } 
void func0() { func1(); } 
int main() { func0(); return 0; } 

नमूना उपयोग:

$ python recursion.py 250000 | g++ -x c++ - && ./a.out 

कम से कम मेरे सिस्टम पर, कॉल स्टैक एस 174602 होने लगता है, इसलिए आपको उस से बड़ा होने के लिए recursion.py पर तर्क सेट करने की आवश्यकता होगी; और प्रोग्राम को संकलित और लिंक करने में कुछ मिनट लगते हैं।

Answer 12

संकलन समय उदाहरण:

template <int N> 
struct Factorial { 
    enum { value = N * Factorial<N - 1>::value }; 
}; 

// ... 
{ 
    int overflow = Factorial<10>::value; 
}