इस प्रश्न का विशिष्ट उत्तर, दुर्भाग्य से यहां पहले से ही पोस्ट किया गया है, एक यह है कि "शेष संचालन से पहले वेतन वृद्धि" करता है और दूसरा "शेष संचालन के बाद वेतन वृद्धि" करता है। हालाँकि यह सहज रूप से विचार को पार कर जाता है, लेकिन यह कथन पूरी तरह से गलत है । समय में घटनाओं का क्रम C # में बहुत अच्छी तरह से परिभाषित किया गया है, और यह मज़बूती से ऐसा मामला नहीं है कि ++ के उपसर्ग (++ संस्करण) और पोस्टफ़िक्स (var ++) संस्करण अन्य कार्यों के संबंध में एक अलग क्रम में चीजें करते हैं।
यह आश्चर्यजनक है कि आप इस प्रश्न के बहुत से गलत उत्तर देखेंगे। एक महान कई "अपने आप को सी # सिखाते हैं" किताबें भी गलत हो जाती हैं। साथ ही, C # करने का तरीका यह बताता है कि C कैसे करता है। बहुत से लोग कारण जैसे कि C # और C एक ही भाषा हैं; वो नहीं हैं। मेरी राय में C # में इंक्रीमेंट और डीक्रीमेंट ऑपरेटर्स का डिज़ाइन इन ऑपरेटर्स सी में डिज़ाइन की खामियों से बचा जाता है।
दो प्रश्न हैं, जिन्हें यह निर्धारित करने के लिए उत्तर दिया जाना चाहिए कि वास्तव में उपसर्ग और पोस्टफ़िक्स ++ का संचालन C # में क्या है। पहला सवाल यह है कि परिणाम क्या है? और दूसरा सवाल यह है कि वेतन वृद्धि का दुष्प्रभाव कब होता है?
यह स्पष्ट नहीं है कि किसी भी प्रश्न का उत्तर क्या है, लेकिन इसे देखने के बाद यह वास्तव में काफी सरल है। एक चर x के लिए x ++ और ++ x ठीक क्या करते हैं, इसके लिए मुझे मंत्र दें।
उपसर्ग फॉर्म (++ x) के लिए:
- चर का उत्पादन करने के लिए x का मूल्यांकन किया जाता है
- चर का मान एक अस्थायी स्थान पर कॉपी किया जाता है
- अस्थायी मूल्य एक नया मान उत्पन्न करने के लिए बढ़ा हुआ है (अस्थायी ओवरराइटिंग नहीं!)
- नया मान चर में संग्रहीत है
- ऑपरेशन का परिणाम नया मान है (यानी अस्थायी का बढ़ा हुआ मूल्य)
उपसर्ग फॉर्म के लिए (x ++):
- चर का उत्पादन करने के लिए x का मूल्यांकन किया जाता है
- चर का मान एक अस्थायी स्थान पर कॉपी किया जाता है
- अस्थायी मूल्य एक नया मान उत्पन्न करने के लिए बढ़ा हुआ है (अस्थायी ओवरराइटिंग नहीं!)
- नया मान चर में संग्रहीत है
- ऑपरेशन का परिणाम अस्थायी का मूल्य है
ध्यान देने योग्य कुछ बातें:
सबसे पहले, समय में घटनाओं का क्रम दोनों मामलों में समान है । फिर, यह बिल्कुल नहीं है कि समय में घटनाओं का क्रम उपसर्ग और पश्चात के बीच बदल जाता है। यह कहना पूरी तरह से गलत है कि मूल्यांकन अन्य मूल्यांकन से पहले या अन्य मूल्यांकन के बाद होता है। मूल्यांकन दोनों मामलों में ठीक उसी क्रम में होता है जैसा कि आप चरण 1 के माध्यम से देख सकते हैं। केवल अंतर यह है अंतिम चरण - परिणाम अस्थायी, या नए, वृद्धि मूल्य के मूल्य है या नहीं।
आप इसे एक सरल सी # कंसोल ऐप के साथ आसानी से प्रदर्शित कर सकते हैं:
public class Application
{
public static int currentValue = 0;
public static void Main()
{
Console.WriteLine("Test 1: ++x");
(++currentValue).TestMethod();
Console.WriteLine("\nTest 2: x++");
(currentValue++).TestMethod();
Console.WriteLine("\nTest 3: ++x");
(++currentValue).TestMethod();
Console.ReadKey();
}
}
public static class ExtensionMethods
{
public static void TestMethod(this int passedInValue)
{
Console.WriteLine("Current:{0} Passed-in:{1}",
Application.currentValue,
passedInValue);
}
}
ये रहे नतीजे ...
Test 1: ++x
Current:1 Passed-in:1
Test 2: x++
Current:2 Passed-in:1
Test 3: ++x
Current:3 Passed-in:3
पहले परीक्षण में, आप देख सकते हैं कि दोनों currentValueऔर क्या पारित किया गया थाTestMethod() विस्तार , उसी मूल्य को दिखाते हैं, जैसा कि अपेक्षित था।
हालांकि, दूसरे मामले में, लोग आपको यह बताने की कोशिश करेंगे कि कॉल के बाद होने वाली वेतन वृद्धि होती currentValueहै , लेकिन जैसा कि आप परिणामों से देख सकते हैं, यह कॉल से पहले होता है जैसा कि 'वर्तमान: 2' परिणाम से संकेत मिलता है।TestMethod()
इस स्थिति में, पहले का मान currentValueअस्थायी में संग्रहीत किया जाता है। अगला, उस मूल्य का एक संवर्धित संस्करण वापस संग्रहीत किया जाता है, currentValueलेकिन अस्थायी को छूने के बिना जो अभी भी मूल मूल्य को संग्रहीत करता है। अंत में उस अस्थायी को पारित कर दिया जाता है TestMethod()। यदि वेतन वृद्धि कॉल के बाद हुई है TestMethod()तो यह समान, गैर-वेतन वृद्धि दो बार लिखेगा, लेकिन ऐसा नहीं होता है।
यह ध्यान रखना महत्वपूर्ण है कि दोनों currentValue++और ++currentValueसंचालन से लौटाया गया मान अस्थायी पर आधारित होता है, न कि उस समय जब चर प्रचालन से बाहर होता है, तब चर में संग्रहीत वास्तविक मूल्य।
ऊपर दिए गए संचालन के क्रम में याद करें, पहले दो चरण अस्थायी में चर के तत्कालीन मूल्य को कॉपी करते हैं। यही वह है जो रिटर्न मान की गणना करने के लिए उपयोग किया जाता है; उपसर्ग संस्करण के मामले में, यह है कि प्रत्यय संस्करण के मामले में जबकि अस्थायी मूल्य में वृद्धि हुई है, यह उस मूल्य को सीधे / गैर-संवर्धित है। अस्थायी में प्रारंभिक भंडारण के बाद चर को फिर से नहीं पढ़ा जाता है।
और अधिक सरल रूप से कहें, तो उपसर्ग संस्करण उस मान को लौटाता है जो चर से पढ़ा गया था (यानी अस्थायी का मान) जबकि उपसर्ग संस्करण उस मान को लौटाता है जो चर पर वापस लिखा गया था (यानी अस्थायी का बढ़ा हुआ मूल्य)। न ही चर का मान लौटाएं।
यह समझना महत्वपूर्ण है क्योंकि चर स्वयं अस्थिर हो सकता है और किसी अन्य थ्रेड पर बदल गया है जिसका अर्थ है कि उन कार्यों का वापसी मूल्य चर में संग्रहीत वर्तमान मूल्य से भिन्न हो सकता है।
लोगों में पूर्ववर्तीता, सहानुभूति के बारे में बहुत भ्रमित होना आश्चर्यजनक है, और जिस क्रम में साइड इफेक्ट्स निष्पादित किए जाते हैं, मुझे ज्यादातर संदेह होता है क्योंकि यह सी # में इतना भ्रामक है ध्यान से इन सभी मामलों में कम भ्रमित होने के लिए डिज़ाइन किया गया है। इन मुद्दों के कुछ अतिरिक्त विश्लेषण के लिए, मेरे सहित इस विचार के मिथ्यात्व को प्रदर्शित करता है कि उपसर्ग और उपसर्ग संचालन "सामान को समय में चारों ओर ले जाते हैं" देखें:
https://ericlippert.com/2009/08/10/precedence-vs-order-redux/
जिसके कारण यह SO प्रश्न:
int [] गिरफ्तारी = {0}; int value = arrest [गिरफ्तारी [0] ++]; मान = 1?
आपको इस विषय पर मेरे पिछले लेखों में भी दिलचस्पी हो सकती है:
https://ericlippert.com/2008/05/23/precedence-vs-associativity-vs-order/
तथा
https://ericlippert.com/2007/08/14/c-and-the-pit-of-despair/
और एक दिलचस्प मामला जहां सी को शुद्धता के बारे में तर्क देना मुश्किल हो जाता है:
https://docs.microsoft.com/archive/blogs/ericlippert/bad-recursion-revisited
इसके अलावा, हम अन्य ऑपरेशनों पर विचार करते समय समान सूक्ष्म मुद्दों में भाग लेते हैं, जिनके साइड इफेक्ट होते हैं, जैसे कि जंजीर सरल कार्य:
https://docs.microsoft.com/archive/blogs/ericlippert/chaining-simple-assignments-is-not-so-simple
और यहाँ क्यों वेतन वृद्धि ऑपरेटरों में परिणाम पर कोई रोचक पोस्ट है मूल्यों बल्कि की तुलना में सी # में चर :
मैं C- जैसी भाषाओं में ++ i ++ क्यों नहीं कर सकता?