पाश के लिए पोस्टफ़िक्स और एक में उपसर्ग वेतन वृद्धि ऑपरेटर

Question

संभव डुप्लिकेट:
Difference between i++ and ++i in a loop?

किसी को भी उन के बीच अंतर क्या व्याख्या कर सकते हैं:

for(unsigned col = 0; col < n; ++col, num_to_fill >>= 1U) 
{ 

    for(unsigned row = num_to_fill; row < (1U << n); row += (num_to_fill * 2)) 
    { 
     std::fill_n(&output[col][row], num_to_fill, 1); 
    } 
} 

और

for(unsigned col = 0; col < n; col++, num_to_fill >>= 1U) 
{ 

    for(unsigned row = num_to_fill; row < (1U << n); row += (num_to_fill * 2)) 
    { 
     std::fill_n(&output[col][row], num_to_fill, 1); 
    } 
} 

जब col=0, ex.1 Output[col][row] में output[1][row] हो जाएगा और ex.2 Output[col][row] में output[0][row] हो जाएगा। क्या मैं सही हू ?

प्रश्न 2: /= 2 के बजाय का उपयोग करना कोई फर्क पड़ता है?

Answer 1

यह col के मूल्य में कोई फर्क नहीं पड़ता है - मानते हैं कि col एक आदिम मूल्य है। यदि col एक वर्ग था, तो उपसर्ग और पोस्टफिक्स '++' ऑपरेटरों को दो अलग-अलग चीजों को करने के लिए ओवरलोड किया जा सकता है, हालांकि मैं इसे खराब अभ्यास मानता हूं। निम्न उदाहरण पर विचार करें:

#include <iostream> 

using namespace std; 

int main() { 
    for(int i = 0; i < 10; i++) { 
     cout << i << endl; 
    } 

    cout << endl; 

    for(int i = 0; i < 10; ++i) { 
     cout << i << endl; 
    } 

} 

इनमें से

दोनों बस, 0 से 9 से प्रिंट तथ्य यह है कि आप पहले से वेतन वृद्धि एक में, और अन्य में के बाद वेतन वृद्धि के बावजूद। i की वृद्धि लूप के प्रत्येक भाग के अंत में होती है चाहे आप प्री या पोस्ट वृद्धि का उपयोग करें या नहीं। मेरा मानना ​​है कि प्री-इंक्रिमेंटिंग अधिक कुशल है, क्योंकि - और मैं यहां गलत हो सकता हूं - कंपाइलर को अस्थायी चर ^1. का उपयोग करने की आवश्यकता नहीं है, लेकिन यह केवल ध्यान देने योग्य होगा यदि आप बहुत लंबे समय तक लूपिंग कर रहे हैं (और निश्चित रूप 'More computing sins are committed in the name of efficiency than for any other single reason')

प्रश्न 2 के लिए के रूप में की।

प्रश्न 2: का उपयोग कर सकते हैं >> = 1 यू बजाय =/2 कोई फर्क?

असंभव। यदि कंपेलर ऑप्टिमाइज़ नहीं किया गया है तो बिट स्थानांतरण तेजी से होगा, लेकिन संभावना है कि आपका कंपाइलर इसे थोड़ा बदलाव में अनुकूलित करेगा।

एक तरफ ध्यान दें के रूप में, मैं आम तौर पर unsigned variableName कर (जो है, int छोड़ने) को खोजने के खराब व्यवहार का - हालांकि सी ++ एक int कहीं भी एक में धक्का देना होगा याद आ रही है, यह कम मेरे लिए पठनीय है।

1.: टिप्पणी में स्टीफन (एक अलग स्टीफन;)) लिखते हैं कि - "पूर्व वेतन वृद्धि मानक पुस्तकालय कंटेनर iterators के लिए और अधिक कुशल है, लेकिन यह आदिम प्रकार के लिए अलग नहीं है, एक पूर्णांक को कॉपी के बाद से एक बड़ा इटरेटर (विशेष रूप से std :: set और std :: map iterators) की प्रतिलिपि बनाने से सस्ता है। "

Answer 2

unsigned के लिए कोई अंतर नहीं है। हालांकि, ओवरलोडेड operator++ वाले वर्गों के लिए एक अंतर होगा, क्योंकि यह अपने अलग ओवरलोड को कॉल करेगा (आमतौर पर, पोस्टफिक्स ऑपरेटर कक्षा की एक प्रति बनाता है, जिसका अर्थ है कि यह धीमा हो सकता है)।

>> = 1U के बजाय/= 2 का उपयोग करना कोई फर्क पड़ता है?

शायद नहीं। इसके अर्थशास्त्र अनिश्चित के लिए समान हैं, और संकलक आमतौर पर उन्हें समान रूप से व्यवहार करते हैं और यदि तेज़ी से होते हैं तो एक दूसरे को बदल सकते हैं।