क्या लूप के भीतर एक चर घोषित करने के लिए कोई उपरि है? (C ++)

Question 1

मैं बस सोच रहा हूं कि अगर आपने ऐसा कुछ किया तो गति या दक्षता का कोई नुकसान होगा:

int i = 0;
while(i < 100)
{
    int var = 4;
    i++;
}

जो int varएक सौ बार घोषित करता है । यह मुझे लगता है जैसे वहाँ होगा, लेकिन मुझे यकीन नहीं है। इसके बजाय ऐसा करना अधिक व्यावहारिक / तेज़ होगा:

int i = 0;
int var;
while(i < 100)
{
    var = 4;
    i++;
}

या वे एक ही हैं, गति और दक्षता बुद्धिमान?

Question 2

स्थानीय चर के लिए स्टैक स्पेस आमतौर पर फ़ंक्शन स्कोप में आवंटित किया जाता है। तो लूप के अंदर कोई स्टैक पॉइंटर एडजस्टमेंट नहीं होता है, बस 4 से असाइन करना है var। इसलिए इन दो स्निपेट्स का एक ही ओवरहेड होता है।

Question 3

आदिम प्रकार और POD प्रकारों के लिए, इससे कोई फर्क नहीं पड़ता। कंपाइलर फ़ंक्शन की शुरुआत में वेरिएबल के लिए स्टैक स्पेस आवंटित करेगा और फ़ंक्शन को दोनों मामलों में वापस आने पर इसे हटा देगा।

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

Question 4

वे दोनों समान हैं, और यहां बताया गया है कि कंपाइलर क्या करता है, यह देखकर आप यह पता लगा सकते हैं (भले ही अनुकूलन उच्च पर सेट न हो):

देखें कि संकलक (gcc 4.0) आपके सरल उदाहरणों के लिए क्या करता है:

1.c:

main(){ int var; while(int i < 100) { var = 4; } }

gcc -S 1. सी

1.s:

_main:
    pushl   %ebp
    movl    %esp, %ebp
    subl    $24, %esp
    movl    $0, -16(%ebp)
    jmp L2
L3:
    movl    $4, -12(%ebp)
L2:
    cmpl    $99, -16(%ebp)
    jle L3
    leave
    ret

2.c

main() { while(int i < 100) { int var = 4; } }

gcc -S 2.c

2.s:

_main:
        pushl   %ebp
        movl    %esp, %ebp
        subl    $24, %esp
        movl    $0, -16(%ebp)
        jmp     L2
L3:
        movl    $4, -12(%ebp)
L2:
        cmpl    $99, -16(%ebp)
        jle     L3
        leave
        ret

इनसे, आप दो चीजें देख सकते हैं: सबसे पहले, कोड दोनों में समान है।

दूसरे, var के लिए स्टोरेज को लूप के बाहर आवंटित किया गया है:

         subl    $24, %esp

और अंत में लूप की एकमात्र चीज़ असाइनमेंट और कंडीशन चेक है:

L3:
        movl    $4, -12(%ebp)
L2:
        cmpl    $99, -16(%ebp)
        jle     L3

जो लगभग उतना ही कुशल है जितना कि आप लूप को पूरी तरह से हटाए बिना हो सकते हैं।

Question 5

इन दिनों इसे लूप के अंदर घोषित करना बेहतर होता है जब तक कि यह स्थिर न हो क्योंकि कंपाइलर कोड को बेहतर तरीके से ऑप्टिमाइज़ कर सकेगा (वेरिएबल स्कोप को कम करना)।

संपादित करें: यह उत्तर अब ज्यादातर अप्रचलित है। पोस्ट-शास्त्रीय संकलक के उदय के साथ, संकलक जहां यह पता नहीं लगा सकते हैं वे दुर्लभ हो रहे हैं। मैं अभी भी उनका निर्माण कर सकता हूं लेकिन अधिकांश लोग निर्माण को खराब कोड के रूप में वर्गीकृत करेंगे।

Question 6

अधिकांश आधुनिक संकलक आपके लिए इसका अनुकूलन करेंगे। कहा जा रहा है कि मैं आपके पहले उदाहरण का उपयोग करूंगा क्योंकि मुझे यह अधिक पठनीय लगता है।

Question 7

अंतर्निहित प्रकार के लिए संभवतः 2 शैलियों के बीच कोई अंतर नहीं होगा (शायद उत्पन्न कोड के ठीक नीचे)।

हालाँकि, यदि वैरिएबल एक गैर-तुच्छ कंस्ट्रक्टर / डिस्ट्रक्टर वाला एक वर्ग है, तो रनटाइम लागत में एक बड़ा अंतर हो सकता है। मैं आम तौर पर लूप के अंदर वेरिएबल को स्कोप करता हूं (स्कोप को जितना हो सके उतना छोटा रखने के लिए), लेकिन अगर यह एक पूर्ण प्रभाव पड़ता है तो मैं लूप के दायरे से बाहर क्लास वेरिएबल को ले जाना चाहूंगा। हालाँकि, ऐसा करने के लिए कुछ अतिरिक्त विश्लेषण की आवश्यकता होती है क्योंकि ओओड पथ के शब्दार्थ बदल सकते हैं, इसलिए यह केवल तभी किया जा सकता है यदि शब्दार्थ इसे पसंद करता है।

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

मान लें कि आपके पास एक ऐसा LockMgrवर्ग है जो निर्माण होने पर एक महत्वपूर्ण खंड प्राप्त करता है और नष्ट होने पर इसे जारी करता है:

while (i< 100) {
    LockMgr lock( myCriticalSection); // acquires a critical section at start of
                                      //    each loop iteration

    // do stuff...

}   // critical section is released at end of each loop iteration

इससे काफी अलग है:

LockMgr lock( myCriticalSection);
while (i< 100) {

    // do stuff...

}

Question 8

दोनों छोरों में एक ही दक्षता है। वे दोनों एक अनंत समय लेंगे :) यह छोरों के अंदर वृद्धि करने के लिए एक अच्छा विचार हो सकता है।

Question 9

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

Question 10

#include <stdio.h>
int main()
{
    for(int i = 0; i < 10; i++)
    {
        int test;
        if(i == 0)
            test = 100;
        printf("%d\n", test);
    }
}

ऊपर कोड हमेशा 100 10 बार प्रिंट करता है जिसका अर्थ है कि लूप के अंदर स्थानीय चर प्रत्येक फ़ंक्शन कॉल के अनुसार एक बार आवंटित किया जाता है।

Question 11

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

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

Question 12

केवल दो चर के साथ, संकलक को संभवतः दोनों के लिए एक रजिस्टर असाइन किया जाएगा। ये रजिस्टर वैसे भी हैं, इसलिए इसमें समय नहीं लगता है। किसी भी मामले में 2 रजिस्टर राइट और एक रजिस्टर रीड इंस्ट्रक्शन हैं।

Question 13

मुझे लगता है कि अधिकांश उत्तर इस बात पर विचार करने के लिए एक प्रमुख बिंदु याद कर रहे हैं कि: "क्या यह स्पष्ट है" और स्पष्ट रूप से सभी चर्चा से तथ्य यह है; नहीं ऐसा नहीं है। मैं सबसे अधिक लूप कोड में सुझाव दूंगा कि दक्षता बहुत अधिक गैर-मुद्दा है (जब तक कि आप एक मंगल लैंडर के लिए गणना नहीं कर रहे हैं), इसलिए वास्तव में एकमात्र सवाल यह है कि क्या अधिक समझदार और पठनीय और रखरखाव योग्य लगता है - इस मामले में मैं घोषणा करने की सिफारिश करूंगा। चर सामने और पाश के बाहर - यह बस इसे स्पष्ट करता है। तब आपके और मेरे जैसे लोग ऑनलाइन जाँच करने में समय बर्बाद करने की जहमत नहीं उठाएँगे कि यह वैध है या नहीं।

Question 14

यह सच नहीं है कि इसके ऊपरी हिस्से में उपेक्षा की जा सकती है।

भले ही शायद वे स्टैक पर एक ही स्थान पर समाप्त हो जाएंगे यह अभी भी इसे असाइन करता है। यह उस इंट के लिए मेमोरी लोकेशन को असाइन करेगा और फिर इसे} के अंत में फ्री करेगा। नहीं मुक्त भाव में अर्थ में यह 1 से sp (स्टैक पॉइंटर) को स्थानांतरित करेगा और आपके मामले में केवल एक स्थानीय चर पर विचार करने से यह बस fp (फ्रेम पॉइंटर) और सपा के बराबर होगा

संक्षिप्त उत्तर होगा: इस देखभाल को पूरा करने के लिए समान काम करना होगा।

लेकिन स्टैक कैसे आयोजित किया जाता है, इस पर अधिक पढ़ने का प्रयास करें। मेरे अंडरग्रेजुएट स्कूल में इस पर बहुत अच्छे व्याख्यान थे यदि आप यहाँ अधिक जाँच पढ़ना चाहते हैं http://www.cs.utk.edu/~plank/plank/classes/cs360/360/notes/Assembler1/lecture.html