c - जो तेज़ है: जबकि(1) या जबकि(2)?




performance while-loop (15)

यह एक वरिष्ठ प्रबंधक द्वारा पूछे जाने वाले एक साक्षात्कार प्रश्न था।

कौन सा तेज़ है?

while(1) {
    // Some code
}

या

while(2) {
    //Some code
}

मैंने कहा कि दोनों में एक ही निष्पादन गति है, क्योंकि अंत में अभिव्यक्ति को आखिरकार true या false मूल्यांकन करना चाहिए। इस मामले में, दोनों true मूल्यांकन करते true और हालात के अंदर कोई अतिरिक्त सशर्त निर्देश नहीं हैं। तो, दोनों निष्पादन की एक ही गति होगी और मैं (1) पसंद करते हैं।

लेकिन साक्षात्कारकर्ता ने आत्मविश्वास से कहा: "अपनी मूल बातें जांचें। while(1) से तेज है।" (वह मेरे आत्मविश्वास का परीक्षण नहीं कर रहा था)

क्या ये सच है?

यह भी देखें: "((;;)" के दौरान "तेज़" (TRUE) "है? यदि नहीं, तो लोग इसका उपयोग क्यों करते हैं?


आपकी व्याख्या सही है। ऐसा एक प्रश्न प्रतीत होता है जो तकनीकी ज्ञान के अतिरिक्त आपके आत्मविश्वास का परीक्षण करता है।

वैसे, अगर आपने उत्तर दिया

कोड के दोनों टुकड़े समान रूप से तेज़ होते हैं, क्योंकि दोनों को पूरा करने के लिए अनंत समय लगता है

साक्षात्कारकर्ता कहेंगे

लेकिन while (1) प्रति सेकंड अधिक पुनरावृत्तियों कर सकते हैं; क्या आप व्यख्या कर सकते हैं? (यह बकवास है; फिर से अपने आत्मविश्वास का परीक्षण)

तो आपके जैसा जवाब देकर, आपने कुछ समय बचाया जिसे आप अन्यथा इस बुरे प्रश्न पर चर्चा करने पर बर्बाद कर देंगे।

ऑप्टिमाइज़ेशन बंद होने के साथ, मेरे सिस्टम (एमएस विजुअल स्टूडियो 2012) पर कंपाइलर द्वारा जेनरेट किया गया एक उदाहरण कोड यहां दिया गया है:

yyy:
    xor eax, eax
    cmp eax, 1     (or 2, depending on your code)
    je xxx
    jmp yyy
xxx:
    ...

अनुकूलन के साथ चालू:

xxx:
    jmp xxx

तो जेनरेट कोड कम से कम एक अनुकूलक कंपाइलर के साथ समान है।


आपको उससे पूछा जाना चाहिए कि वह उस निष्कर्ष पर कैसे पहुंचा। वहां किसी भी सभ्य कंपाइलर के तहत, दोनों एक ही एएसएम निर्देशों के लिए संकलित करते हैं। तो, उसे आपको कंपाइलर को भी शुरू करना चाहिए था। और फिर भी, आपको सैद्धांतिक शिक्षित अनुमान बनाने के लिए संकलक और मंच को बहुत अच्छी तरह से जानना होगा। और अंत में, यह वास्तव में अभ्यास में कोई फर्क नहीं पड़ता है, क्योंकि मेमोरी विखंडन या सिस्टम लोड जैसे अन्य बाहरी कारक हैं जो इस विवरण से अधिक लूप को प्रभावित करेंगे।


इस समस्या में इतने सारे लोगों को देखने के लिए, यह दिखाता है कि यह जांचने के लिए बहुत अच्छी तरह से जांच क्यों हो सकती है कि आप चीजों को माइक्रो-ऑप्टिमाइज़ करना कितनी जल्दी चाहते हैं।

मेरा जवाब होगा; इससे कोई फर्क नहीं पड़ता, मैं उस व्यवसाय की समस्या पर ध्यान केंद्रित करता हूं जिसे हम हल कर रहे हैं। आखिरकार, यही वह है जिसके लिए मुझे भुगतान किया जा रहा है।

इसके अलावा, मैं while(1) {} लिए चुनता हूं क्योंकि यह अधिक आम है, और अन्य टीम के साथी को यह जानने के लिए समय बिताने की आवश्यकता नहीं होगी कि कोई 1 से अधिक संख्या के लिए क्यों जाएगा।

अब कुछ कोड लिखें। ;-)


इस सवाल के लिए, मुझे यह जोड़ना चाहिए कि मुझे सी कमेटी के लेखन से डौग ग्विन याद है कि ऑप्टिमाइज़र पास के बिना कुछ प्रारंभिक सी कंपाइलर्स while(1) लिए असेंबली में एक परीक्षण उत्पन्न करेंगे while(1) (तुलना for(;;) तुलना में यह नहीं है)।

मैं इस ऐतिहासिक नोट देकर साक्षात्कारकर्ता का जवाब दूंगा और फिर कहूंगा कि अगर मैं बहुत ही आश्चर्यचकित हूं कि किसी भी कंपाइलर ने ऐसा किया है, तो एक कंपाइलर हो सकता है:

  • ऑप्टिमाइज़र पास किए बिना कंपाइलर while(1) और while(2) दोनों के लिए एक परीक्षण उत्पन्न करता है
  • ऑप्टिमाइज़र पास करने के साथ संकलक को सभी while(1) बिना शर्त कूद) अनुकूलित करने के निर्देश दिए जाते हैं while(1) क्योंकि उन्हें मूर्खतापूर्ण माना जाता है। यह एक परीक्षण के साथ while(2) छोड़ देगा और इसलिए दोनों के बीच एक प्रदर्शन अंतर बनाता है।

मैं निश्चित रूप से साक्षात्कारकर्ता को जोड़ता हूं जो while(1) और while(2) पर विचार नहीं करता है, वही निर्माण कम गुणवत्ता वाले अनुकूलन का संकेत है क्योंकि ये समकक्ष संरचनाएं हैं।


ऐसा लगता है कि यह एक तकनीकी प्रश्न के रूप में मुखौटा उन व्यवहारिक साक्षात्कार प्रश्नों में से एक है। कुछ कंपनियां ऐसा करती हैं - वे एक तकनीकी प्रश्न पूछेंगे जो किसी भी सक्षम प्रोग्रामर के उत्तर देने के लिए काफी आसान होना चाहिए, लेकिन जब साक्षात्कारकर्ता सही उत्तर देता है, तो साक्षात्कारकर्ता उन्हें बताएगा कि वे गलत हैं।

कंपनी देखना चाहती है कि आप इस स्थिति में कैसे प्रतिक्रिया देंगे। क्या आप वहां चुपचाप बैठते हैं और साक्षात्कारकर्ता को परेशान करने के डर के कारण आपका जवाब सही नहीं है? या आप प्राधिकरण में किसी व्यक्ति को चुनौती देने के इच्छुक हैं जो आपको पता है गलत है? वे देखना चाहते हैं कि क्या आप अपने दृढ़ विश्वासों के लिए खड़े होने के इच्छुक हैं, और यदि आप इसे एक कुशल और सम्मानजनक तरीके से कर सकते हैं।


किसी विशेष संकलक के लिए किसी विशेष लक्ष्य के लिए किसी विशेष कंपाइलर द्वारा उत्पन्न कोड को दिखाते हुए मौजूदा उत्तरों प्रश्न का पूरी तरह उत्तर नहीं देते हैं - जब तक उस विशिष्ट संदर्भ में प्रश्न पूछा नहीं गया था ("जो x86_64 के लिए जीसीसी 4.7.2 का उपयोग कर तेज़ है डिफ़ॉल्ट विकल्प के साथ? ", उदाहरण के लिए)।

जहां तक ​​भाषा परिभाषा का संबंध है, सारणी मशीन में while (1) पूर्णांक निरंतर 1 मूल्यांकन करता है, और while (2) पूर्णांक निरंतर 2 मूल्यांकन करता है; दोनों मामलों में परिणाम समानता के लिए शून्य से तुलना की जाती है। भाषा मानक दो संरचनाओं के सापेक्ष प्रदर्शन के बारे में बिल्कुल कुछ नहीं कहता है।

मैं कल्पना कर सकता हूं कि एक बेहद बेवकूफ संकलक दो रूपों के लिए अलग-अलग मशीन कोड उत्पन्न कर सकता है, कम से कम जब अनुकूलन का अनुरोध किए बिना संकलित किया जाता है।

दूसरी तरफ, सी कंपाइलर्स को संकलन समय पर कुछ निरंतर अभिव्यक्तियों का मूल्यांकन करना चाहिए, जब वे उन संदर्भों में दिखाई देते हैं जिन्हें निरंतर अभिव्यक्ति की आवश्यकता होती है। उदाहरण के लिए, यह:

int n = 4;
switch (n) {
    case 2+2: break;
    case 4:   break;
}

एक निदान की आवश्यकता है; एक आलसी कंपाइलर में निष्पादन समय तक 2+2 के मूल्यांकन को रोकने का विकल्प नहीं है। चूंकि एक कंपाइलर में संकलन समय पर निरंतर अभिव्यक्तियों का मूल्यांकन करने की क्षमता होती है, इसलिए इसके लिए कोई अच्छा कारण नहीं है कि उस क्षमता का लाभ न उठाए, जब भी इसकी आवश्यकता न हो।

सी मानक ( N1570 1570 N1570 पी 4) कहते हैं कि

एक पुनरावृत्ति कथन एक बयान का कारण बनता है जिसे लूप बॉडी को बार-बार निष्पादित किया जाता है जब तक कि नियंत्रण अभिव्यक्ति 0 के बराबर न हो।

तो प्रासंगिक निरंतर अभिव्यक्ति 1 == 0 और 2 == 0 , जिनमें से दोनों int मान 0 मूल्यांकन करते हैं। (ये तुलना while के अर्थशास्त्र में अंतर्निहित हैं; वे वास्तविक सी अभिव्यक्ति के रूप में मौजूद नहीं हैं।)

एक विकृत बेवकूफ संकलक दो संरचनाओं के लिए अलग कोड उत्पन्न कर सकता है । उदाहरण के लिए, पहले के लिए यह एक बिना शर्त अनंत लूप उत्पन्न कर सकता है (एक विशेष मामले के रूप में 1 इलाज), और दूसरे के लिए यह 2 != 0 बराबर एक स्पष्ट रन-टाइम तुलना उत्पन्न कर सकता है। लेकिन मुझे कभी भी एक सी संकलक का सामना नहीं हुआ है जो वास्तव में उस तरह से व्यवहार करेगा, और मुझे गंभीरता से संदेह है कि ऐसा संकलक मौजूद है।

अधिकांश कंपाइलर्स (मैं सभी उत्पादन-गुणवत्ता वाले कंपाइलरों को कहने का लुत्फ उठाता हूं) में अतिरिक्त अनुकूलन का अनुरोध करने के विकल्प हैं। इस तरह के एक विकल्प के तहत, यह भी कम संभावना है कि कोई भी कंपाइलर दो रूपों के लिए अलग-अलग कोड उत्पन्न करेगा।

यदि आपका कंपाइलर दो संरचनाओं के लिए अलग-अलग कोड उत्पन्न करता है, तो पहले जांचें कि भिन्न कोड अनुक्रमों में वास्तव में अलग-अलग प्रदर्शन हैं या नहीं। यदि वे करते हैं, तो ऑप्टिमाइज़ेशन विकल्प (यदि उपलब्ध हो) के साथ फिर से संकलन करने का प्रयास करें। यदि वे अभी भी भिन्न हैं, तो कंपाइलर विक्रेता को एक बग रिपोर्ट सबमिट करें। यह सी (मानक) सी मानक के अनुरूप होने में विफलता की भावना में एक बग नहीं है, लेकिन यह लगभग निश्चित रूप से एक समस्या है जिसे सही किया जाना चाहिए।

निचली पंक्ति: while (1) और while(2) लगभग निश्चित रूप से एक ही प्रदर्शन है। उनके पास बिल्कुल वही अर्थशास्त्र है, और किसी भी कंपाइलर के लिए समान कोड उत्पन्न नहीं करने का कोई अच्छा कारण नहीं है।

और यद्यपि यह while(1) के लिए while(1) के लिए तेज़ कोड उत्पन्न करने के लिए एक संकलक के लिए पूरी तरह से कानूनी है, while(2) यह एक कंपाइलर के लिए while(1) तुलना में तेज़ कोड उत्पन्न करने के लिए समान रूप से कानूनी है while(1) एक ही कार्यक्रम

(आपके द्वारा पूछे गए एक और सवाल में निहित एक सवाल है: आप एक साक्षात्कारकर्ता से कैसे निपटते हैं जो गलत तकनीकी बिंदु पर जोर देता है। यह शायद कार्यस्थल साइट के लिए एक अच्छा सवाल होगा)।


दोनों लूप अनंत हैं, लेकिन हम देख सकते हैं कि प्रति पुनरावृत्ति के लिए कौन सा निर्देश / संसाधन लेता है।

जीसीसी का उपयोग करके, मैंने दो निम्नलिखित कार्यक्रमों को अनुकूलन के विभिन्न स्तरों पर असेंबली में संकलित किया:

int main(void) {
    while(1) {}
    return 0;
}


int main(void) {
    while(2) {}
    return 0;
}

यहां तक ​​कि कोई अनुकूलन ( -O0 ) के साथ, जेनरेटेड असेंबली दोनों कार्यक्रमों के लिए समान थी। इसलिए, दो loops के बीच कोई गति अंतर नहीं है।

संदर्भ के लिए, यहां जेनरेट असेंबली है ( gcc main.c -S -masm=intel का उपयोग ऑप्टिमाइज़ेशन ध्वज के साथ):

-O0 साथ:

    .file   "main.c"
    .intel_syntax noprefix
    .def    __main; .scl    2;  .type   32; .endef
    .text
    .globl  main
    .def    main;   .scl    2;  .type   32; .endef
    .seh_proc   main
main:
    push    rbp
    .seh_pushreg    rbp
    mov rbp, rsp
    .seh_setframe   rbp, 0
    sub rsp, 32
    .seh_stackalloc 32
    .seh_endprologue
    call    __main
.L2:
    jmp .L2
    .seh_endproc
    .ident  "GCC: (tdm64-2) 4.8.1"

-O1 साथ:

    .file   "main.c"
    .intel_syntax noprefix
    .def    __main; .scl    2;  .type   32; .endef
    .text
    .globl  main
    .def    main;   .scl    2;  .type   32; .endef
    .seh_proc   main
main:
    sub rsp, 40
    .seh_stackalloc 40
    .seh_endprologue
    call    __main
.L2:
    jmp .L2
    .seh_endproc
    .ident  "GCC: (tdm64-2) 4.8.1"

-O2 और -O3 (एक ही आउटपुट) के साथ:

    .file   "main.c"
    .intel_syntax noprefix
    .def    __main; .scl    2;  .type   32; .endef
    .section    .text.startup,"x"
    .p2align 4,,15
    .globl  main
    .def    main;   .scl    2;  .type   32; .endef
    .seh_proc   main
main:
    sub rsp, 40
    .seh_stackalloc 40
    .seh_endprologue
    call    __main
.L2:
    jmp .L2
    .seh_endproc
    .ident  "GCC: (tdm64-2) 4.8.1"

वास्तव में, लूप के लिए उत्पन्न असेंबली अनुकूलन के प्रत्येक स्तर के समान है:

 .L2:
    jmp .L2
    .seh_endproc
    .ident  "GCC: (tdm64-2) 4.8.1"

महत्वपूर्ण बिट्स हैं:

.L2:
    jmp .L2

मैं असेंबली को बहुत अच्छी तरह से पढ़ नहीं सकता, लेकिन यह स्पष्ट रूप से बिना शर्त लूप है। jmp निर्देश बिना शर्त रूप से कार्यक्रम को रीसेट करता है .L2 लेबल को सच के खिलाफ एक मूल्य की तुलना किए बिना, और निश्चित रूप से तब तक ऐसा तब तक करता है जब तक प्रोग्राम किसी भी तरह समाप्त नहीं हो जाता है। यह सीधे सी / सी ++ कोड से मेल खाता है:

L2:
    goto L2;

संपादित करें:

दिलचस्प है, यहां तक ​​कि कोई अनुकूलन के साथ, निम्नलिखित लूप सभी ने असेंबली में सटीक उसी आउटपुट (बिना शर्त jmp ) का उत्पादन किया:

while(42) {}

while(1==1) {}

while(2==2) {}

while(4<7) {}

while(3==3 && 4==4) {}

while(8-9 < 0) {}

while(4.3 * 3e4 >= 2 << 6) {}

while(-0.1 + 02) {}

और यहां तक ​​कि मेरे आश्चर्य के लिए:

#include<math.h>

while(sqrt(7)) {}

while(hypot(3,4)) {}

उपयोगकर्ता परिभाषित कार्यों के साथ चीजें थोड़ा और दिलचस्प हो जाती हैं:

int x(void) {
    return 1;
}

while(x()) {}


#include<math.h>

double x(void) {
    return sqrt(7);
}

while(x()) {}

At -O0 , इन दो उदाहरणों में वास्तव में x कॉल किया जाता है और प्रत्येक पुनरावृत्ति के लिए तुलना निष्पादित करता है।

पहला उदाहरण (1 लौट रहा है):

.L4:
    call    x
    testl   %eax, %eax
    jne .L4
    movl    $0, %eax
    addq    $32, %rsp
    popq    %rbp
    ret
    .seh_endproc
    .ident  "GCC: (tdm64-2) 4.8.1"

दूसरा उदाहरण ( sqrt(7) लौट रहा है):

.L4:
    call    x
    xorpd   %xmm1, %xmm1
    ucomisd %xmm1, %xmm0
    jp  .L4
    xorpd   %xmm1, %xmm1
    ucomisd %xmm1, %xmm0
    jne .L4
    movl    $0, %eax
    addq    $32, %rsp
    popq    %rbp
    ret
    .seh_endproc
    .ident  "GCC: (tdm64-2) 4.8.1"

हालांकि, -O1 - -O1 और ऊपर, वे दोनों पिछले उदाहरणों के समान असेंबली का उत्पादन करते हैं (पिछले लेबल में एक बिना शर्त jmp )।

टी एल; डॉ

जीसीसी के तहत, अलग-अलग लूप समान असेंबली में संकलित किए जाते हैं। कंपाइलर स्थिर मानों का मूल्यांकन करता है और किसी वास्तविक तुलना करने से परेशान नहीं होता है।

कहानी का नैतिक है:

  • सी ++ स्रोत कोड और सीपीयू निर्देशों के बीच अनुवाद की एक परत मौजूद है, और इस परत के प्रदर्शन के लिए महत्वपूर्ण प्रभाव हैं।
  • इसलिए, केवल स्रोत कोड को देखकर प्रदर्शन का मूल्यांकन नहीं किया जा सकता है।
  • संकलक ऐसे छोटे मामलों को अनुकूलित करने के लिए पर्याप्त स्मार्ट होना चाहिए । कार्यक्रमकारों को अपने अधिकांश समय के बारे में सोचने में अपना समय बर्बाद नहीं करना चाहिए

निस्संदेह मैं इस प्रबंधक के असली इरादों को नहीं जानता, लेकिन मैं एक पूरी तरह से अलग दृष्टिकोण का प्रस्ताव करता हूं: जब एक टीम में एक नए सदस्य को भर्ती करते हैं, तो यह जानना उपयोगी होता है कि वह संघर्ष स्थितियों पर कैसे प्रतिक्रिया करता है।

उन्होंने आपको संघर्ष में ले जाया। यदि यह सच है, तो वे चतुर हैं और सवाल अच्छा था। कुछ उद्योगों के लिए, बैंकिंग की तरह, स्टैक ओवरफ़्लो में आपकी समस्या पोस्ट करना अस्वीकृति का कारण हो सकता है।

लेकिन निश्चित रूप से मुझे नहीं पता, मैं सिर्फ एक विकल्प का प्रस्ताव करता हूं।


मुझे लगता है कि सुराग "वरिष्ठ प्रबंधक द्वारा पूछा गया" में पाया जाना है। जब वह प्रबंधक बन गया तो इस व्यक्ति ने प्रोग्रामिंग को स्पष्ट रूप से रोक दिया और फिर उसे वरिष्ठ प्रबंधक बनने के लिए कई सालों लगे। प्रोग्रामिंग में कभी भी रुचि नहीं खोई, लेकिन उन दिनों से कभी भी एक पंक्ति नहीं लिखी। इसलिए उनके संदर्भ में "कोई सभ्य कंपाइलर नहीं है" जैसा कि कुछ उत्तरों का उल्लेख है, लेकिन "इस व्यक्ति ने 20-30 साल पहले इस कंपाइलर के साथ काम किया था"।

उस समय, प्रोग्रामर ने अपने कोड को तेजी से और अधिक कुशल बनाने के लिए विभिन्न तरीकों का प्रयास करने के अपने समय का काफी प्रतिशत खर्च किया क्योंकि 'केंद्रीय मिनीकंप्यूटर' का सीपीयू समय इतना मूल्यवान था। जैसा कि लोग कंपाइलर्स लिखते थे। मैं अनुमान लगा रहा हूं कि उस समय एकमात्र कंपाइलर जिसने अपनी कंपनी को उपलब्ध कराया था, उस समय 'अनुकूलित किए गए वक्तव्य जिन्हें अनुकूलित किया जा सकता है' के आधार पर अनुकूलित किया गया था और थोड़ी देर का सामना करते समय एक शॉर्टकट लिया (1) और सबकुछ का मूल्यांकन किया अन्यथा, थोड़ी देर सहित (2)। ऐसा अनुभव होने के कारण उसकी स्थिति और उसके आत्मविश्वास की व्याख्या हो सकती है।

आपको किराए पर लेने का सबसे अच्छा तरीका शायद एक ऐसा व्यक्ति है जो वरिष्ठ प्रबंधक को आगे ले जाने में सक्षम बनाता है और आपको अगले साक्षात्कार विषय की ओर ले जाने से पहले "प्रोग्रामिंग के अच्छे पुराने दिनों" पर 2-3 मिनट का व्याख्यान देता है। (अच्छा समय यहां महत्वपूर्ण है - बहुत तेज़ और आप कहानी को बाधित कर रहे हैं - बहुत धीमी है और आपको अपर्याप्त फोकस वाले किसी के रूप में लेबल किया गया है)। साक्षात्कार के अंत में उसे बताएं कि आप इस विषय के बारे में अधिक जानने में रुचि रखते हैं।


यहां एक समस्या है: यदि आप वास्तव में एक प्रोग्राम लिखते हैं और इसकी गति मापते हैं, तो दोनों लूप की गति अलग हो सकती है! For some reasonable comparison:

unsigned long i = 0;
while (1) { if (++i == 1000000000) break; }

unsigned long i = 0;
while (2) { if (++i == 1000000000) break; }

with some code added that prints the time, some random effect like how the loop is positioned within one or two cache lines could make a difference. One loop might by pure chance be completely within one cache line, or at the start of a cache line, or it might to straddle two cache lines. And as a result, whatever the interviewer claims is fastest might actually be fastest - by coincidence.

Worst case scenario: An optimising compiler doesn't figure out what the loop does, but figures out that the values produced when the second loop is executed are the same ones as produced by the first one. And generate full code for the first loop, but not for the second.


If you're that worried about optimisation, you should use

for (;;)

because that has no tests. (cynic mode)


Judging by the amount of time and effort people have spent testing, proving, and answering this very straight forward question Id say that both were made very slow by asking the question.

And so to spend even more time on it ...

"while (2)" is ridiculous, because,

"while (1)", and "while (true)" are historically used to make an infinite loop which expects "break" to be called at some stage inside the loop based upon a condition that will certainly occur.

The "1" is simply there to always evaluate to true and therefore, to say "while (2)" is about as silly as saying "while (1 + 1 == 2)" which will also evaluate to true.

And if you want to be completely silly just use: -

while (1 + 5 - 2 - (1 * 3) == 0.5 - 4 + ((9 * 2) / 4)) {
    if (succeed())
        break;
}

Id like to think your coder made a typo which did not effect the running of the code, but if he intentionally used the "2" just to be weird then sack him before he puts weird sh!t all through your code making it difficult to read and work with.


Since people looking to answer this question want the fastest loop, I would have answered that both are equally compiling into the same assembly code, as stated in the other answers. Nevertheless you can suggest to the interviewer using 'loop unrolling'; a do {} while loop instead of the while loop.

Cautious: You need to ensure that the loop would at least always run once .

The loop should have a break condition inside.

Also for that kind of loop I would personally prefer the use of do {} while(42) since any integer, except 0, would do the job.


That depends on the compiler.

If it optimizes the code, or if it evaluates 1 and 2 to true with the same number of instructions for a particular instruction set, the execution speed will be the same.

In real cases it will always be equally fast, but it would be possible to imagine a particular compiler and a particular system when this would be evaluated differently.

I mean: this is not really a language (C) related question.


They are both equal - the same.

According to the specifications anything that is not 0 is considered true, so even without any optimization, and a good compiler will not generate any code for while(1) or while(2). The compiler would generate a simple check for != 0 .





while-loop