C Language
दुष्प्रभाव

प्री / पोस्ट इन्क्रीमेंट / डिक्रीमेंट ऑपरेटर

C में, दो संयुक्त संचालक हैं - '++' और '-' जो भ्रम का बहुत ही सामान्य स्रोत हैं। ऑपरेटर ++ वेतन वृद्धि ऑपरेटर और ऑपरेटर कहा जाता है -- घटती ऑपरेटर कहा जाता है। उन दोनों या तो उपसर्ग फार्म या पोस्टफ़िक्स रूप में प्रयोग किया जा सकता है। ++ ऑपरेटर के लिए उपसर्ग फॉर्म का सिंटैक्स ++operand और पोस्टफिक्स फॉर्म के लिए सिंटैक्स operand++ । जब उपसर्ग रूप में उपयोग किया जाता है, तो ऑपरेंड को पहले 1 से बढ़ा दिया जाता है और अभिव्यक्ति के मूल्यांकन में ऑपरेटर के परिणामी मूल्य का उपयोग किया जाता है। निम्नलिखित उदाहरण पर विचार करें:

int n, x = 5;
n = ++x; /* x is incremented  by 1(x=6), and result is assigned to n(6) */
         /* this is a short form for two statements: */
         /* x = x + 1; */ 
         /* n = x ; */

जब उपसर्ग रूप में उपयोग किया जाता है, तो अभिव्यक्ति में ऑपरेंड के वर्तमान मूल्य का उपयोग किया जाता है और फिर ऑपरेंड के मूल्य को 1 से बढ़ा दिया जाता है। निम्नलिखित उदाहरण पर विचार करें:

int n, x = 5;
n = x++; /* value of x(5) is assigned first to n(5), and then x is incremented by 1; x(6) */
         /* this is a short form for two statements: */
         /* n = x; */
         /* x = x + 1; */

वेतन वृद्धि ऑपरेटर का कार्य -- समान रूप से समझा जा सकता है।

निम्न कोड दर्शाता है कि प्रत्येक क्या करता है

    int main()
    {
        int a, b, x = 42;
        a = ++x; /* a and x are 43 */
        b = x++; /* b is 43, x is 44 */
        a = x--; /* a is is 44, x is 43 */
        b = --x; /* b and x are 42 */
        
        return 0;
    }

ऊपर से यह स्पष्ट है कि पोस्ट ऑपरेटर्स किसी वेरिएबल का करंट वैल्यू लौटाते हैं और फिर उसे संशोधित करते हैं, लेकिन प्री ऑपरेटर्स वेरिएबल को मॉडिफाई करते हैं और फिर मॉडिफाइड वैल्यू वापस करते हैं।

सी के सभी संस्करणों में, पूर्व और पोस्ट ऑपरेटरों के मूल्यांकन के क्रम को परिभाषित नहीं किया गया है, इसलिए निम्नलिखित कोड अप्रत्याशित आउटपुट वापस कर सकते हैं:

    int main()
    {
        int a, x = 42;
        a = x++ + x; /* wrong */
        a = x + x; /* right */
        ++x;

        int ar[10];
        x = 0;
        ar[x] = x++; /* wrong */
        ar[x++] = x; /* wrong */
        ar[x] = x; /* right */
        ++x;
        return 0;
    }

ध्यान दें कि एक बयान में अकेले इस्तेमाल किए जाने पर पोस्ट ऑपरेटर्स से पहले उपयोग करना भी अच्छा अभ्यास है। इसके लिए उपरोक्त कोड देखें।

ध्यान दें, जब कोई फ़ंक्शन कहा जाता है, तो फ़ंक्शन चलने से पहले तर्कों पर सभी दुष्प्रभाव होने चाहिए।

    int foo(int x)
    {
        return x;
    }

    int main()
    {
        int a = 42;
        int b = foo(a++);  /* This returns 43, even if it seems like it should return 42 */
        return 0;
    }