ක්‍රමලේඛකයෙකු ලෙස ඔබ පැහැදිලිවම පුනරාවර්තනයක් හේතුවෙන් තොග පිටාර ගැලීමේ දෝෂය දනී. නමුත් එම දෝෂය මඟහරවා ගැනීම සඳහා ඔබේ ප්‍රියතම භාෂාව ලබා ගැනීමට අමුතු හා අසාමාන්‍ය ක්‍රම බොහොමයක් තිබේ.

අරමුණු:

1. දෝෂ ප්‍රතිදානයේ පැහැදිලිව පෙනෙන පරිදි තොග පිටාර ගැලීමක් සිදුවිය යුතුය.
2. පැහැදිලි පුනරාවර්තනයක් භාවිතා කිරීමට අවසර නැත.

අවලංගු වැඩසටහන් සඳහා උදාහරණ:

// Invalid, direct obvious recursion.
methodA(){ methodA(); }

// Invalid, indirect, but obvious recursion.
methodA(){ methodB(); }
methodB(){ methodA(); }

වඩාත්ම ජනප්‍රිය නිර්මාණ තරඟයක් ලෙස වඩාත් නිර්මාණාත්මක ක්‍රම හොඳම වේ. එනම්, මේ වගේ පැහැදිලි පිළිතුරු නීරස කිරීමෙන් වළකින්න:

throw new StackOverflowError(); // Valid, but very boring and downvote-deserving.

මම දැන් පිළිතුරක් පිළිගත්තද, තවත් පිළිතුරු එකතු කිරීම තවමත් හරි :)

පයිතන්

import sys
sys.setrecursionlimit(1)

මෙය පරිවර්තකයා වහාම අසමත් වීමට හේතු වේ:

$ cat test.py
import sys
sys.setrecursionlimit(1)
$ python test.py
Exception RuntimeError: 'maximum recursion depth exceeded' in <function _remove at 0x10e947b18> ignored
Exception RuntimeError: 'maximum recursion depth exceeded' in <function _remove at 0x10e8f6050> ignored
$ 

පුනරාවර්තනය භාවිතා කරනවා වෙනුවට, එය තොගය හැකිලී යන බැවින් එය වහාම පිටාර ගැලෙනු ඇත.

පයිතන්

import webbrowser
webbrowser.open("http://stackoverflow.com/")

සී / ලිනක්ස් 32 බිට්

void g(void *p){
        void *a[1];
        a[2]=p-5;
}
void f(){
        void *a[1];
        g(a[2]);
}
main(){
        f();
        return 0;
}

ආපසු ලිපිනය නැවත ලිවීමෙන් ක්‍රියා කරයි, එබැවින් ඇමතීමට පෙර gස්ථානයට නැවත පැමිණේ . ආපසු ලිපින තොගයේ ඇති ඕනෑම වේදිකාවක් සඳහා ක්‍රියා කරනු ඇත, නමුත් නවක වදන් අවශ්‍ය විය හැකිය.mainf

ඇත්ත වශයෙන්ම, අරාවකින් පිටත ලිවීම නිර්වචනය නොකළ හැසිරීමක් වන අතර , එය ඔබේ උඩු රැවුල නිල් පැහැයෙන් පින්තාරු කරනවාට වඩා තොග පිටාර ගැලීමක් ඇති කරන බවට ඔබට සහතිකයක් නැත. වේදිකාව, සම්පාදක සහ සම්පාදක කොඩි පිළිබඳ විස්තර විශාල වෙනසක් ඇති කළ හැකිය.

JavaScript / DOM

with (document.body) {
    addEventListener('DOMSubtreeModified', function() {
        appendChild(firstChild);
    }, false);

    title = 'Kill me!';
}

ඔබට ඔබගේ බ්‍රව්සරය විනාශ කිරීමට අවශ්‍ය නම් එය කොන්සෝලය තුළ අත්හදා බලන්න.

ජාවා

මෙතන කොහේ හරි මේ වගේ දෙයක් දැක්කා:

සංස්කරණය කරන්න: මා එය දුටු තැන හමු විය: ස්ටැක් ඕවර්ෆ්ලෝ දෝෂය විසි කරන කෙටිම වැඩසටහනට ජෝ කේගේ පිළිතුර

public class A {
    String val;
    public String toString() {
        return val + this;
    }

    public static void main(String[] args) {
        System.out.println(new A());
    }
}

එය සමහර ජාවා ආරම්භකයින් ව්‍යාකූල කළ හැකිය. එය හුදෙක් පුනරාවර්තන ඇමතුම සඟවයි. val + thisනූල් val + this.toString()නිසා val.

එය මෙහි ක්‍රියාත්මක වන ආකාරය බලන්න: http://ideone.com/Z0sXiD

සී

ඉතා පහසුයි:

int main()
{
    int large[10000000] = {0};
    return 0;
}

සී හි පුනරාවර්තන නොවන තොග පිටාර ගැලීම

සම්මුතියේ නොගැලපීම කැඳවීම.

typedef void __stdcall (* ptr) (int);

void __cdecl hello (int x) { }

void main () {
  ptr goodbye = (ptr)&hello;
  while (1) 
    goodbye(0);
}

සමඟ සම්පාදනය කරන්න gcc -O0.

__cdeclකාර්යයන් මඟින් ඇමතුම තොගය පිරිසිදු කරනු ඇතැයි අපේක්ෂා කරන අතර, ඇමතුම එය කිරීමට __stdcallඅපේක්ෂා කරයි, එබැවින් යතුරු ලියන ශ්‍රිත දර්ශකය හරහා ඇමතීමෙන්, පිරිසිදු කිරීම කිසි විටෙකත් සිදු නොවේ - සෑම mainඇමතුමකටම පරාමිතිය තොගයට තල්ලු කරයි, නමුත් කිසිවක් එය නොපවතින අතර අවසානයේ තොග පිරවීම.

ජාවාස්ක්‍රිප්ට්

window.toString = String.toLocaleString;
+this;

මගේ පෙර පිළිතුරේ ජාවා 7 සහ ජාවා 8 මගේ නපුරු කේතයට ප්‍රතිශක්තීකරනය වීම ගැන මම කලකිරීමට පත් වීමි . ඒ නිසා මම තීරණය කළා ඒ සඳහා පැච් එකක් අවශ්‍යයි කියලා.

සාර්ථකත්වය! මම printStackTrace()විසි කළා StackOverflowError. printStackTrace()නිදොස් කිරීම සහ ලොග් වීම සඳහා බහුලව භාවිතා වන අතර එය භයානක යැයි කිසිවෙකු සාධාරණ ලෙස සැක නොකරයි. බරපතල ආරක්ෂක ගැටළු කිහිපයක් නිර්මාණය කිරීම සඳහා මෙම කේතය අනිසි ලෙස භාවිතා කළ හැකි බව දැකීම දුෂ්කර නොවේ:

public class StillMoreEvilThanMyPreviousOne {
    public static void main(String[] args) {
        try {
            evilMethod();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static void evilMethod() throws Exception {
        throw new EvilException();
    }

    public static class EvilException extends Exception {
        @Override
        public Throwable getCause() {
            return new EvilException();
        }
    }
}

මෙය පැහැදිලි පුනරාවර්තනයක් යැයි සමහර අය සිතනු ඇත. එය එසේ නොවේ ය. මෙම EvilExceptionඉදිකිරීමටත් ආමන්ත්රණය කරන්නේ නැත getCause()ක්රමය නිසා බව හැර සැබවින්ම සියලු පසු ආරක්ෂිතව දමනු කළ හැක. getCause()ක්රමය ඇමතීමෙන් StackOverflowErrorඑකක්වත් නොලැබේ . පුනරාවර්තනය ජේඩීකේ හි සාමාන්‍යයෙන් සැක සහිත printStackTrace()හැසිරීමක් වන අතර ව්‍යතිරේකය පරීක්ෂා කිරීම සඳහා භාවිතා කරන නිදොස් කිරීම සහ ලොග් වීම සඳහා වන තෙවන පාර්ශවීය පුස්තකාලය තුළ වේ. තවද, ව්‍යතිරේකය විසි කරන ස්ථානය එය හසුරුවන ස්ථානයට වඩා බොහෝ දුරින් විය හැකිය.

කෙසේ හෝ වේවා, මෙහි කේතයක් ඇත StackOverflowError අතර සියල්ලටම පසු පුනරාවර්තන ක්‍රම ඇමතුම් අඩංගු නොවේ. මෙම StackOverflowErrorපිටත සිදු mainJDK ගණන්වල, ක්රමය UncaughtExceptionHandler:

public class StillMoreEvilThanMyPreviousOneVersion2 {
    public static void main(String[] args) {
        evilMethod();
    }

    private static void evilMethod() {
        throw new EvilException();
    }

    public static class EvilException extends RuntimeException {
        @Override
        public Throwable getCause() {
            return new EvilException();
        }
    }
}

Exception: java.lang.StackOverflowError thrown from the UncaughtExceptionHandler in thread "main"

ලිනක්ස් x86 NASM එකලස් කිරීම

section .data
    helloStr:     db 'Hello world!',10 ; Define our string
    helloStrLen:  equ $-helloStr       ; Define the length of our string

section .text
    global _start

    doExit:
        mov eax,1 ; Exit is syscall 1
        mov ebx,0 ; Exit status for success
        int 80h   ; Execute syscall

    printHello:
        mov eax,4           ; Write syscall is No. 4
        mov ebx,1           ; File descriptor 1, stdout
        mov ecx,helloStr    ; Our hello string
        mov edx,helloStrLen ; The length of our hello string
        int 80h             ; execute the syscall

    _start:
        call printHello ; Print "Hello World!" once
        call doExit     ; Exit afterwards

ස්පොයිලර්:

PrintHello වෙතින් ආපසු යාමට අමතක වීම නිසා අපි නැවතත් _start වෙතට පනින්නෙමු.

සම්පාදනය කරන වේලාවේදී C ++

template <unsigned N>
struct S : S<N-1> {};

template <>
struct S<0> {};

template
struct S<-1>;

$ g ++ -c test.cc -ftemplate-deep = 40000
g ++: අභ්‍යන්තර සම්පාදක දෝෂය: ඛණ්ඩනය කිරීමේ දෝෂය (වැඩසටහන cc1plus)
කරුණාකර සම්පූර්ණ දෝෂ වාර්තාවක් ඉදිරිපත් කරන්න,
සුදුසු නම් පෙර සැකසූ ප්‍රභවයක් සමඟ.
උපදෙස් සඳහා බලන්න.

මෙම ප්‍රභව ගොනුවේ පුනරාවර්තනයක් නොමැත, එක් පන්තියකටම මූලික පංතියක් ලෙස නැත, වක්‍රව පවා නැත. (C ++ දී, මේ වගේ සැකිල්ල පන්තියේ, S<1>සහ S<2>සම්පූර්ණයෙන්ම වෙනස් වර්ග වේ.) මෙම segmentation fault සම්පාදකවරයා දී සහානුයාත වලට පසු පිරී ඉතිරී ගොඩගසන්න කිරීමට නියමිතය.

බෑෂ් (අන්තරා අනතුරු ඇඟවීම)

while true
do 
  mkdir x
  cd x
done

නිශ්චිතවම කිවහොත්, එය පිටාර ගැලීම කෙලින්ම ගබඩා නොකරනු ඇත, නමුත් " නොනවත්වා ගලා බසින උත්පාදක තත්වයක් " ලෙස ලේබල් කළ හැකි දේ ජනනය කරයි : ඔබේ තැටිය පිරී යන තෙක් ඔබ මෙය ක්‍රියාත්මක කරන විට සහ "rm -rf" සමඟ ඇති අවුල ඉවත් කිරීමට අවශ්‍ය විට x ", එය පහර වැදී ඇත.

සෑම පද්ධතියකම එය සිදු නොවේ. සමහර ඒවා අනෙක් ඒවාට වඩා ශක්තිමත් ය.

අනතුරු ඇඟවීම:

සමහර පද්ධති මෙය ඉතා නරක ලෙස හසුරුවන අතර ඔබට පිරිසිදු කිරීම ඉතා අසීරු විය හැකිය (මන්ද "rm -rf" ම පුනරාවර්තන ගැටලුවකට වැටෙනු ඇත). පිරිසිදු කිරීම සඳහා ඔබට සමාන පිටපතක් ලිවීමට සිදු විය හැකිය.

විශ්වාස නැතිනම් සීරීම් වීඑම් එකකින් මෙය උත්සාහ කිරීම හොඳය.

PS: කණ්ඩායම් ස්ක්‍රිප්ට් එකකින් ක්‍රමලේඛනය කර හෝ කර තිබේ නම් එයම අදාළ වේ.
පීපීඑස්: ඔබෙන් අදහස් දැක්වීමක් මැදිහත් විය හැකිය, ඔබේ විශේෂිත පද්ධතිය හැසිරෙන ආකාරය ...

ජාවා

ජාවා ප්‍රහේලිකා වලින් ලස්සන එකක් . එය මුද්‍රණය කරන්නේ කුමක්ද?

public class Reluctant {
    private Reluctant internalInstance = new Reluctant();

    public Reluctant() throws Exception {
        throw new Exception("I'm not coming out");
    }

    public static void main(String[] args) {
        try {
            Reluctant b = new Reluctant();
            System.out.println("Surprise!");
        } catch (Exception ex) {
            System.out.println("I told you so");
        }
    }
}

එය ඇත්ත වශයෙන්ම StackOverflowError සමඟ අසමත් වේ.

ඉදිකිරීම්කරුගේ ව්යතිරේකය රතු හුරුල්ලන් පමණි. පොතට ඒ ගැන කියන්නට ඇත්තේ මෙයයි:

ඔබ ඉදිකිරීම්කරුවකුට ආයාචනා කරන විට, නිදර්ශන විචල්‍ය ආරම්භකයෝ ඉදිකිරීම්කරුගේ සිරුර ඉදිරිපිට ධාවනය වේ . මෙම අවස්ථාවෙහිදී, විචල්‍යය සඳහා වන internalInstanceආරම්භකය නැවත නැවත ඉදිකිරීම්කරුට ආයාචනා කරයි. එම ඉදිකිරීම්කරු, තමන්ගේම internalInstanceක්ෂේත්‍රයක් ආරම්භ කරන්නේ, අකමැත්තෙන් ඉදිකිරීම්කරුට නැවත නැවතත් ආයාචනා කිරීමෙනි. මෙම පුනරාවර්තන ආයාචනා මඟින් StackOverflowErrorඉදිකිරීම්කරුගේ ශරීරයට කවදා හෝ ක්‍රියාත්මක වීමට අවස්ථාවක් ලැබෙනු ඇත. ඊට වඩා StackOverflowErrorඋප ප්‍රභේදයක් වන නිසා , අල්ලා ගැනීමේ වගන්තිය එය අල්ලා නොගනී.ErrorExceptionmain

LaTeX

\end\end

ආදාන තොගය පිටාර ගැලීම නිසා \end පැහැදිලි කළ ආකාරයට, නැවත නැවතත් අනන්ත පුඩුවක් තුල ම පුළුල් මෙතන .

ටෙක්ස් අසමත් වන්නේ ඒ TeX capacity exceeded, sorry [input stack size=5000]හා සමාන ය.

බීඑෆ්

අවසානයේදී තොගය පිරී ඉතිරී යනු ඇත, පරිවර්තකයා තොගය කොපමණ කාලයක් සාදයිද යන්න මත රඳා පවතී ...

+[>+]

C #, සම්පාදනය කරන වේලාවේදී

මයික්‍රොසොෆ්ට් සී # සම්පාදකයා එහි තොගය පුපුරවා හැරීමට හේතු ගණනාවක් තිබේ; C # සම්පාදකයාගේ "ප්‍රකාශනය සම්පාදනය කිරීමට නොහැකි තරම් සංකීර්ණ" දෝෂයක් ඔබ දකින ඕනෑම වේලාවක එය තොගය පුපුරා ගොස් ඇති නිසාය.

විග්‍රහකය පුනරාවර්තන සම්භවයක් ඇති බැවින් ප්‍රමාණවත් තරම් ගැඹුරින් කැදැලි සහිත භාෂා ව්‍යුහයන් තොගය පුපුරවා හරිනු ඇත:

 class C { class C { class C { ....

සාමාන්‍යයෙන් පුනරාවර්තනය වන පැත්තේ පුනරාවර්තන ඉවත් කිරීම ගැන ප්‍රකාශන විග්‍රහකය ඉතා දක්ෂයි. සාමාන්යයෙන්:

x = 1 + 1 + 1 + 1 + .... + 1;

විශාල ගැඹුරු විග්‍රහ ගසක් සාදන, එය තොගය පුපුරන්නේ නැත. නමුත් පුනරාවර්තනය අනෙක් පැත්තෙන් සිදුවීමට ඔබ බල කරන්නේ නම්:

x = 1 + (1 + (1 + (1 + ....+ (1 + 1))))))))))))))))))))))))))))))))))))))))))...;

එවිට තොගය පුපුරවා හැරිය හැක.

මෙම වැඩසටහන ඉතා විශාල බව අනවශ්‍ය දේපල ඇත. වර්ග ක්‍රමයේ ඇතැම් අමුතු චක්‍ර ඉවත් කිරීමට තරම් බුද්ධිමත් නොවන නිසා, අර්ථකථන විශ්ලේෂකය කුඩා වැඩසටහනක් සමඟ අසීමිත පුනරාවර්තනයකට යොමු කිරීමට ද හැකිය. (රොස්ලින් මෙය වැඩිදියුණු කළ හැකිය.)

public interface IN<in U> {}
public interface IC<X> : IN<IN<IC<IC<X>>>> {}
...
IC<double> bar = whatever;
IN<IC<string>> foo = bar;  // Is this assignment legal? 

මෙම විශ්ලේෂණය මෙහි අසීමිත පුනරාවර්තනයකට යන්නේ මන්දැයි මම විස්තර කරමි:

http://blogs.msdn.com/b/ericlippert/archive/2008/05/07/covariance-and-contravariance-part-twelve-to-infinity-but-not-beyond.aspx

තවත් බොහෝ රසවත් උදාහරණ සඳහා ඔබ මෙම පත්‍රය කියවිය යුතුය:

http://research.microsoft.com/en-us/um/people/akenn/generics/FOOL2007.pdf

අන්තර්ජාලයේ (දිනකට බිලියන සංඛ්‍යාත ජනතාවක් භාවිතා කරයි)

Redirects, HTTP status code: 301

උදාහරණයක් ලෙස, ඩෙල් ආධාරක වෙබ් අඩවියේ (වරදක් නැත, සමාවෙන්න ඩෙල්):

ඔබ URL වෙතින් TAG සහය ඉවත් කළහොත් එය අනන්ත යළි-යොමුවීම් වලට යයි . පහත දැක්වෙන URL හි, ###### යනු ඕනෑම ආධාරක TAG වේ.

http://www.dell.com/support/drivers/uk/en/ukdhs1/ServiceTag/######?s=BSD&~ck=mn

මම විශ්වාස කරන්නේ එය තොග පිටාර ගැලීමකට සමාන බවයි.

PHP

ලූප මූලද්‍රව්‍ය වලින් පමණක් සිදුකරන ස්ටක් ඕවර් ප්‍රවාහයක්.

$a = array(&$a);
while (1) {
    foreach ($a as &$tmp) {
        $tmp = array($tmp, &$a);
    }
}

පැහැදිලි කිරීම (ස්පොයිලර් බැලීමට සැරිසරන්න):

පරිවර්තකයා කසළ එකතු කිරීමට උත්සාහ කරන විට වැඩසටහන segfault වනු ඇත $tmp විට ( $tmpමෙහි නැවත පැවරීමේදී ) . අරාව ඉතා ගැඹුරු නිසා (ස්වයං යොමු කිරීම) පසුව කුණු එකතු කරන්නා පුනරාවර්තනයකින් අවසන් වේ.

ජාවා

මම හරියටම ප්‍රතිවිරුද්ධ දෙය කළෙමි - පැහැදිලිවම තොග පිටාර ගැලීමේ දෝෂයක් විසි කළ යුතු වැඩසටහනකි, නමුත් එසේ නොවේ.

public class Evil {
    public static void main(String[] args) {
        recurse();
    }

    private static void recurse() {
        try {
            recurse();
        } finally {
            recurse();
        }
    }
}

ඉඟිය: වැඩසටහන O (2 ⁿ ) වේලාවෙන් ක්‍රියාත්මක වන අතර n යනු තොගයේ ප්‍රමාණය (සාමාන්‍යයෙන් 1024) වේ.

සිට ජාවා Puzzlers # 45:

අපගේ යන්ත්‍රයට තත්පරයට ඇමතුම් 10 ¹⁰ ක් ක්‍රියාත්මක කළ හැකි අතර තත්පරයට ව්‍යතිරේක 10 ¹⁰ ක් උත්පාදනය කළ හැකිය , එය වර්තමාන ප්‍රමිතීන්ට අනුව තරමක් ත්‍යාගශීලී ය. මෙම උපකල්පන යටතේ, වැඩසටහන වසර 1.7 × 10 ²⁹¹ කින් අවසන් වේ . මෙය ඉදිරිදර්ශනය කිරීම සඳහා, අපගේ සූර්යයාගේ ආයු කාලය අවුරුදු 10 ¹⁰ ක් ලෙස ගණන් බලා ඇත , එබැවින් මෙම වැඩසටහන අවසන් වනවා දැකීමට අප කිසිවෙකු නොසිටීම ආරක්ෂිත ඔට්ටුවකි. එය අසීමිත පුඩුවක් නොවුනත්, එය එසේ විය හැකිය.

සී #

පළමු ලිපිය, එබැවින් කරුණාකර මා වෙත පහසුවෙන් යන්න.

class Program
{
    static void Main()
    {
        new System.Diagnostics.StackTrace().GetFrame(0).GetMethod().Invoke(null, null);
    }
}

මෙය හුදෙක් තොග හෝඩුවාවක් නිර්මාණය කරයි, ඉහළ රාමුව අල්ලා ගනී (එය අපගේ අවසාන ඇමතුම වනු ඇත Main()), ක්‍රමවේදය ලබාගෙන එය ක්‍රියාත්මක කරයි.

ජාවා

• ජාවා 5 හි, printStackTrace()අසීමිත ලූපයකට ඇතුල් වේ.
• ජාවා 6 හි, printStackTrace()විසි කරයි StackOverflowError.
• ජාවා 7 සහ 8 දී එය සවි කරන ලදී.

පිස්සු කාරණය නම් ජාවා 5 සහ 6 හි එය පරිශීලක කේතයෙන් නොපැමිණීමයි, එය සිදුවන්නේ ජේඩීකේ කේතයේ ය. printStackTrace()මරණීය දණ්ඩනය අනතුරුදායක විය හැකි සාධාරණ සැකකරුවන් කිසිවෙකු නැත .

public class Bad {
    public static void main(String[] args) {
        try {
            evilMethod();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static void evilMethod() throws Exception {
        Exception a = new Exception();
        Exception b = new Exception(a);
        a.initCause(b);
        throw a;
    }
}

JavaScript: පුනරාවර්තන නොවන, ක්‍රියාකාරී ශ්‍රිත විකෘතිය

var f = function() {
    console.log(arguments.length);
};

while (true) {
    f = f.bind(null, 1);
    f();
}

මෙහි කිසිඳු පුනරාවර්තනයක් නොමැත. තනි ක්‍රියාකාරී ඇමතුමකින්f තොගය පිරී ඉතිරී යන තෙක් වැඩි වැඩියෙන් තර්ක සමඟ නැවත නැවත ව්‍යංජන කරනු ලැබේ . එමconsole.log ඔබ එය කරන්න ගනී කොපමණ තර්ක බලන්න ඕන නඩුවේ කොටසක් විකල්ප වේ. දක්ෂ JS එන්ජින් මෙය ප්‍රශස්ත නොකරන බවට එය සහතික කරයි.

කෝපි ස්ක්‍රිප්ට් හි කේත-ගොල්ෆ් අනුවාදය, අක්ෂර 28:

f=->
do f=f.bind f,1 while 1

සී # වීර කාව්‍යයක් සමඟ අසමත් වේ

using System.Xml.Serialization;

[XmlRoot]
public class P
{
    public P X { get { return new P(); } set { } }
    static void Main()
    {
        new XmlSerializer(typeof(P)).Serialize(System.Console.Out, new P());
    }
}

එය අසමත් වන ආකාරය වීර කාව්‍යයකි, එය මගේ මනස මුළුමනින්ම ගිල දැමීය:

එය අසීමිත ලෙස පෙනෙන අමුතු රූප මාලාවක එක් රාමුවක් පමණි.

මෙය මෙතෙක් අමුතුම දේ විය යුතුය. කිසිවෙකුට පැහැදිලි කළ හැකිද? පෙනෙන විදිහට, ඉන්ඩෙන්ටේෂන් සඳහා දිනෙන් දින ඉහළ යන අවකාශ ප්‍රමාණය එම සුදු කුට්ටි පෙනෙන්නට හේතු වේ. එය සිදුවන්නේ .NET 4.5 සමඟ Win7 Enterprise x64 මත ය.

මම තවමත් එහි අවසානය දැක නැත. ඔබ වෙනුවට නම් System.Console.Outසමග System.IO.Stream.Null, එය සෑහෙන්න වේගවත් මිය යයි.

පැහැදිලි කිරීම තරමක් සරල ය. මම තනි දේපලක් ඇති පංතියක් සාදමි, එය සෑම විටම එහි අඩංගු වර්ගයට නව අවස්ථාවක් ලබා දෙයි. එබැවින් එය අසීමිත ගැඹුරු වස්තු ධූරාවලියකි. දැන් අපට ඒ හරහා කියවීමට උත්සාහ කරන යමක් අවශ්‍යයි. එතන තමයි මම පාවිච්චි කරන්නේ XmlSerializer, ඒක කරන්නේ. පෙනෙන විදිහට, එය පුනරාවර්තනය භාවිතා කරයි.

bash

_(){ _;};_

පුනරාවර්තනය පැහැදිලිව පෙනෙන බව බොහෝ දෙනා හඳුනාගත හැකි නමුත් එය ලස්සන බව පෙනේ. නොමැත?

ක්‍රියාත්මක කිරීමෙන් පසු, ඔබට මෙය දැකගත හැකිය.

Segmentation fault (core dumped)

හස්කල්

(අවම වශයෙන් දක්වා දුකයි නමුත් ඇත්ත ghc-7.6ක්රියාත්මක වුවත් O1හෝ ඊට වඩා වැඩි අහක ප්රශ්නය උපරිම ඵල කරන්නම්)

main = print $ sum [1 .. 100000000]

ස්මාල්ටෝක්

මෙය මැස්සන් මත නව ක්‍රමයක්
  නිර්මාණය කරයි , එය මැස්ස මත නව ක්‍රමයක්
    නිර්මාණය කරයි , එය මැස්සන් මත නව ක්‍රමයක් නිර්මාණය කරයි, එය
      ...
    ...
  ..
ඉන්පසු එය වෙත මාරු කරයි.

අමතර කුඩා කුළුබඩු පැමිණෙන්නේ එකවර කුහර මතකය සහ ගොඩවල් මතකය අවධාරණය කිරීමෙන්, දිගු හා දිගු ක්‍රම නාමයක් සහ ග්‍රාහකයක් ලෙස විශාල සංඛ්‍යාවක් නිර්මාණය කිරීමෙන්, අපි සිදුරෙන් පහළට වැටෙන විට ... (නමුත් පුනරාවර්තනය අපට මුලින්ම පහර දෙයි ).

පූර්ණ සංඛ්‍යාවෙන් සම්පාදනය කරන්න:

downTheRabbitHole
    |name deeperName nextLevel|

    nextLevel := self * 2.
    name := thisContext selector.
    deeperName := (name , '_') asSymbol.
    Class withoutUpdatingChangesDo:[
        nextLevel class 
            compile:deeperName , (thisContext method source copyFrom:name size+1).
    ].
    Transcript show:self; showCR:' - and down the rabbit hole...'.
    "/ self halt. "/ enable for debugging
    nextLevel perform:deeperName.

තක්සේරු කිරීමෙන් පසු පනින්න "2 downTheRabbitHole"...
... ටික වේලාවකට පසු, ඔබ පුනරාවර්තන එක්සෙන්ෂන් එකක් පෙන්වමින් නිදොස්කරණයක යෙදෙනු ඇත.

එවිට ඔබට සියලු අවුල් පිරිසිදු කළ යුතුය (ස්මාල් ඉන්ටෙගර් සහ ලාර්ජ් ඉන්ටෙගර් යන දෙවර්ගයටම දැන් පුදුම කේත රාශියක් ඇත):

{SmallInteger . LargeInteger } do:[:eachInfectedClass |
    (eachInfectedClass methodDictionary keys 
        select:[:nm| nm startsWith:'downTheRabbitHole_'])
            do:[:each| eachInfectedClass removeSelector:each]

නැතිනම් ඇලිස්ගේ ආශ්චර්යය ඉවත් කරමින් බ්‍රව්සරයේ යම් කාලයක් ගත කරන්න.

හෝඩුවාවේ හිසෙන් සමහරක් මෙන්න:

2 - and down the rabbit hole...
4 - and down the rabbit hole...
8 - and down the rabbit hole...
16 - and down the rabbit hole...
[...]
576460752303423488 - and down the rabbit hole...
1152921504606846976 - and down the rabbit hole...
2305843009213693952 - and down the rabbit hole...
[...]
1267650600228229401496703205376 - and down the rabbit hole...
2535301200456458802993406410752 - and down the rabbit hole...
5070602400912917605986812821504 - and down the rabbit hole...
[...]
162259276829213363391578010288128 - and down the rabbit hole...
324518553658426726783156020576256 - and down the rabbit hole...
[...]
and so on...

PS: "withoutUpdatingChangesFile:" එකතු කරන ලද්දේ ස්මාල්ටෝක් හි නිරන්තර වෙනස්වීම්-ලොග් ගොනුව පිරිසිදු කිරීමෙන් පසුවය.

පීපීඑස්: අභියෝගයට ස්තූතියි: නව හා නව්‍ය දෙයක් ගැන සිතීම විනෝදජනක විය!

පීපීපීඑස්: සමහර ස්මාල්ටෝක් උපභාෂා / අනුවාදයන් පිරී ඉතිරී යන සිරස් රාමු ගොඩට පිටපත් කරන බව මම සටහන් කරමි - එබැවින් මේවා ඒ වෙනුවට මතකයෙන් බැහැර තත්වයකට පත්විය හැකිය.

සී #

ඇත්තෙන්ම විශාලයි struct, පුනරාවර්තනයක් නැත, පිරිසිදු C #, අනාරක්ෂිත කේතය නොවේ.

public struct Wyern
{
    double a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z;
}
public struct Godzilla
{
    Wyern a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z;
}
public struct Cyclops
{
    Godzilla a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z;
}
public struct Titan
{
    Cyclops a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z;
}
class Program
{
    static void Main(string[] args)
    {
        // An unhandled exception of type 'System.StackOverflowException' occurred in ConsoleApplication1.exe
        var A=new Titan();
        // 26×26×26×26×8 = 3655808 bytes            
        Console.WriteLine("Size={0}", Marshal.SizeOf(A));
    }
}

එය පයින් ගැසීමක් ලෙස එය දෝශ නිරාකරණ කවුළු බිඳ දමයි {Cannot evaluate expression because the current thread is in a stack overflow state.}

සහ සාමාන්‍ය අනුවාදය (NPSF3000 යෝජනාවට ස්තූතියි)

public struct Wyern<T>
    where T: struct
{
    T a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z;        
}


class Program
{
    static void Main(string[] args)
    {
        // An unhandled exception of type 'System.StackOverflowException' occurred in ConsoleApplication1.exe
        var A=new Wyern<Wyern<Wyern<Wyern<int>>>>();
    }
}

සී #

අභිබවා ගිය ==ක්‍රියාකරු වැරදි ලෙස ක්‍රියාත්මක කිරීම :

public class MyClass
{
    public int A { get; set; }

    public static bool operator ==(MyClass obj1, MyClass obj2)
    {
        if (obj1 == null)
        {
            return obj2 == null;
        }
        else
        {
            return obj1.Equals(obj2);
        }
    }

    public static bool operator !=(MyClass obj1, MyClass obj2)
    {
        return !(obj1 == obj2);
    }

    public override bool Equals(object obj)
    {
        MyClass other = obj as MyClass;
        if (other == null)
        {
            return false;
        }
        else
        {
            return A == other.A;
        }
    }
}

ක්‍රියාකරු operator==භාවිතා කිරීමෙන් තමාටම ඇමතුමක් ලැබෙන බව කෙනෙකුට පැවසිය හැකිය ==, නමුත් ඔබ සාමාන්‍යයෙන් ඒ ගැන සිතන්නේ නැත ==, එබැවින් එම උගුලට වැටීම පහසුය.

SnakeYAML භාවිතා කරමින් පිළිතුර ආරම්භ කිරීම

class A
{

    public static void main(String[] a)
    {
         new org.yaml.snakeyaml.Yaml().dump(new java.awt.Point());
    }
}

සංස්කරණය කරන්න: එය ඉවත් නොකළේය

එය ක්‍රියාත්මක වන්නේ කෙසේදැයි සොයා බැලීම පා er කයාට පැවරේ: P (ඉඟිය: stackoverflow.com)

මාර්ගය වන විට: පුනරාවර්තනය ගතිකව සාදනු ලබන්නේ SnakeYAML විසිනි (එය අනුක්‍රමික ක්ෂේත්‍ර හඳුනා ගන්නේ කෙසේදැයි ඔබ දන්නේ නම් ඔබ දකිනු ඇත. Point )

සංස්කරණය කරන්න: එය ක්‍රියාත්මක වන ආකාරය පැවසීම:

SnakeYAML යුගලයක් සඳහා බලයි getXXXසහ setXXXඑකම නම සමඟ mthod XXXහා තරගයක නැවත පැමිණීමට වර්ගය පන්දු පිරිනමන්නා ක පරාමිතිය ලෙස සමාන වේ; පුදුමයට කරුණක් නම් Pointපංතියට a ඇති Point getLocation()අතර void setLocation(Point P)එය නැවත පැමිණේ. SnakeYAML එය නොදකින අතර එම විචක්ෂණභාවය සහ StackOverflows නැවත නැවත සිදු කරයි. ඒ තුළ ඔවුන් සමඟ වැඩ කරන විට HashMapසහ ඒ මත stackoverflow.com වෙතින් විමසන විට එය සොයා ගන්නා ලදී.

සී #

වැරදි ලෙස ක්‍රියාත්මක කරන ලද දේපල ලබා ගන්නා තැනැත්තා

class C
{
   public int P { get { return P; } }
}

static void Main()
{
   int p = new C().P;
}