C ++ में "->" ऑपरेटर क्या है?

Question

पढ़ने के बाद छिपे हुए सुविधाओं और सी ++ / एसटीएल के अंधेरे कोनों पर comp.lang.c++.moderated, मैं पूरी तरह से हैरान था कि निम्नलिखित स्निपेट संकलित और विजुअल स्टूडियो 2008 और जी ++ 4.4 दोनों में काम किया।

यहाँ कोड है:

#include <stdio.h>
int main()
{
    int x = 10;
    while (x --> 0) // x goes to 0
    {
        printf("%d ", x);
    }
}

आउटपुट:

9 8 7 6 5 4 3 2 1 0

मुझे लगता है कि यह C है, क्योंकि यह GCC में भी काम करता है। यह मानक में कहां परिभाषित किया गया है, और यह कहां से आया है?

Comments

या यहां तक ​​कि सिर्फ उचित रिक्ति ... मुझे नहीं लगता कि मैंने चर के बीच और कभी ++या --पहले एक जगह देखी है ...

— मैथ्यू शारले

यह "चला जाता है" ऑपरेटर को वापस किया जा सकता है (0 <- x)। और इसके अलावा एक "रन टू" ऑपरेटर (0 <---- x) है। Geez, सबसे मजेदार बात जो मैंने कभी c ++ सिंटैक्स =) +1 के बारे में सवाल के लिए सुनी है।

— सैडिसो

मजेदार रूप से पर्याप्त है, हालांकि व्याख्या बहुत गलत है, यह वर्णन करता है कि कोड सही तरीके से क्या करता है। :)

— नोल्डोरिन

नई वाक्यविन्यास संभावनाओं की कल्पना करें: #define upto ++<, #define downto -->। यदि आप बुरा महसूस कर रहे हैं, तो आप (और ) कर सकते हैं #define for while(और ओह, मानवता लिख सकते हैं ...#define do ) {#define done ;}for x downto 0 do printf("%d\n", x) done

— क्रिस लूत्ज़

कोडिंग की पूरी तरह से नए अभिव्यंजक तरीके की संभावना को खोलता है, इसके लिए कुछ संकलक चेतावनियों को त्यागने के लायक है: बूल चेकनैजेटिव (इंट एक्स) {रिटर्न एक्स <0? सही गलत ); }

— tt

Answer 1

-->संचालक नहीं है। यह वास्तव में दो अलग-अलग ऑपरेटर हैं, --और >।

सशर्त कोड में कमी होती है x, जबकि xमूल (डीक्रिएटेड नहीं) मान लौटाते हैं , और फिर ऑपरेटर के 0उपयोग के साथ मूल मूल्य की तुलना करते हैं >।

बेहतर समझने के लिए, कथन इस प्रकार लिखा जा सकता है:

while( (x--) > 0 )

Comments

फिर, यह उस तरह के रेंज ऑपरेटर की तरह दिखता है।

— चार्ल्स साल्विया

यह कहना कि x पोस्ट-डिक्रिप्टेड है और फिर 0 की तुलना में एक्स के समान है, एक्स की तुलना में 0 के बाद डीक्रिएट किया गया है

— चार्ल्स सल्विया

मुझे नहीं लगता कि यह समान है। मुझे लगता है कि शब्द "फिर" का तात्पर्य है एक आदेश है (पोस्ट में कमी के बाद, एक्स का मूल्य एक कम है)। मुझे लगता है कि कोई भी कह सकता है कि "आप पदावनत एक्स पोस्ट कर रहे हैं और फिर उसके पुराने मूल्य और 0 ..." की तुलना करके इसे स्पष्ट कर सकते हैं। लेकिन यह वैसे भी है। हम सब जानते हैं कि क्या मतलब है।

— जोहान्स शाउब -

जावा में यह भी संकलित :)

— स्टीवन Devijver

इसके लिए नाम, @ जय, खराब प्रोग्रामिंग शैली है :-) यह इस तथ्य से स्पष्ट है कि सवाल पहली जगह में पूछा गया था। यह कुछ हद तक असंबंधित के बजाय वे जिस चीज पर काम कर रहे हैं, उसके लिए संचालकों को बहुत अधिक समझ में आता है, इसलिए while (x-- > 0)यह अधिक उपयुक्त होगा। यह यह भी स्पष्ट करता है कि क्या चल रहा है (कम से कम एक निश्चित-फ़ॉन्ट संपादक में) जिसका अर्थ है कि इस उत्तर में कोष्ठक आवश्यक नहीं होगा।

— paxdiablo

Answer 2

या कुछ और पूरी तरह से अलग ... के लिए xकरने के लिए स्लाइड 0।

while (x --\
            \
             \
              \
               > 0)
     printf("%d ", x);

गणितीय नहीं है, लेकिन ... हर चित्र एक हजार शब्दों को पेंट करता है ...

Comments

@mafutrct - जैसा कि मुझे याद है कि सी में बस अगली लाइन को जोड़ देता है जैसे कि कोई लाइन ब्रेक नहीं था। यहाँ \ N मूल रूप से कुछ नहीं करते हैं।

— होगन

@mafu '\' वर्ण संकलक को बताता है कि अगली पंक्ति में वर्तमान रेखा जारी है और इसलिए संकलक को दोनों रेखाओं को मिलाना चाहिए और एक के रूप में संकलित करना चाहिए। 'जबकि (x -> 0)' तब तक चलेगा जब तक x -1 के बराबर न हो जाए। लेकिन, जिस तरह से वह इंडेंटेशन करता है उससे ऐसा लगता है जैसे x शून्य पर खिसक रहा है। 'जबकि x 0 पर स्लाइड करता है ...'

— '18

IIRC, K & R C ने,-in-decrement ऑपरेटर के बीच व्हाट्सएप की अनुमति दी, जिस स्थिति में आप इसके बीच में बैकस्लैश लगा सकते हैं, जो देखने में और भी अच्छा लगेगा। :)

— जूल्स

@ अर्नव बोरबोराह यह एक पुरानी अभिव्यक्ति का अर्थ है why waste words when a picture does a better job, इस संदर्भ में एक मजाक के रूप में इस्तेमाल किया जाता है। (वास्तव में 2 कीवर्ड हैं ) whileऔरprintf

— अनसंकटेड

आह हाँ, अस्पष्ट स्लाइड ऑपरेटर। मैं कैसे भूल सकता हूं!

— डेन्कोरियू

Answer 3

यह एक बहुत ही जटिल ऑपरेटर है, इसलिए यहां तक ​​कि आईएसओ / आईईसी जेटीसी 1 (संयुक्त तकनीकी समिति 1) ने सी ++ मानक के दो अलग-अलग हिस्सों में अपना विवरण रखा।

एक तरफ मजाक करते हुए, वे दो अलग-अलग ऑपरेटर हैं: --और >क्रमशः .5.2.6 / 2 और C ++ 03 मानक के .95.9 में वर्णित हैं।

Answer 4

इसके बराबर है

while (x-- > 0)

x--(पद में वृद्धि) के बराबर है x = x-1, कोड में बदल जाता है:

while(x > 0) {
    x = x-1;
    // logic
}
x--;   // The post decrement done when x <= 0

Comments

यह बिलकुल सही नहीं है। लूप बॉडी के अंदर x का मान दूसरे मामले में अलग है। आपके उदाहरण में असाइनमेंट स्टेटमेंट इसके समकक्ष होने के लिए तर्क से ऊपर होना चाहिए । उपसर्ग - घटाव 1, लेकिन तुलना घटाव से पहले मूल्य से होगी ।

— १०:०

@ प्रत्यक्षदर्शी ये वास्तव में समकक्ष हैं। यदि उपसर्ग का उपयोग किया जा रहा है तो यह गलत होगा: 0 >-- xइस मामले xमें तर्क से पहले डिक्रिप्ट किया गया है। उपसर्ग में, तर्क को डिक्रीमेंट से पहले निष्पादित किया जाता है और इस प्रकार दोनों नमूने समान होते हैं। बेझिझक उन्हें एक में लिखने के लिए Consoleऔर उन्हें परीक्षण करें।

— एमा

वे अभी भी समकक्ष नहीं हैं। पहले लूप के बाद, x -1 है (या यदि यह अहस्ताक्षरित है तो ओवरफ्लो किया जाता है), दूसरे के बाद, यह 0. है (मान लें कि x नॉन-नेगेटिव शुरू होता है, न तो लूप x या ब्रेक को संशोधित करता है या ...)

— सीज़र

while(x=x-1,x+1 > 0)समतुल्य है।

— एसएस ऐनी

@ साहेब, यहां एक काउंटर उदाहरण है: यदि x 0 के रूप में शुरू होता है, तो मूल लूप के तहत यह -1 से बाहर निकल जाएगा, आपके संस्करण के साथ यह शून्य रहेगा। इसलिए वे समकक्ष नहीं हैं।

— इलियट

Answer 5

x विपरीत दिशा में तेजी से शून्य तक जा सकते हैं:

int x = 10;

while( 0 <---- x )
{
   printf("%d ", x);
}

8 6 4 2

आप एक तीर से गति को नियंत्रित कर सकते हैं!

int x = 100;

while( 0 <-------------------- x )
{
   printf("%d ", x);
}

90 80 70 60 50 40 30 20 10

;)

Comments

कौन सा ऑपरेटिंग सिस्टम, इस प्रकार का आउटपुट उत्पन्न हुआ, मैं एक ubuntu 12.04 का उपयोग कर रहा हूं, जिसमें मुझे एक त्रुटि संदेश था

— भुवनेश

हालांकि यह स्पष्ट होना चाहिए, C ++ पढ़ने वाले सभी लोगों के लिए: यह मत करो। यदि आपको एक से अधिक वृद्धि / वृद्धि की आवश्यकता है, तो संवर्धित असाइनमेंट का उपयोग करें।

— Blimeo

"लेज़रों" के साथ शून्य। जबकि (0> - - - - - - - - - - ---------- x) ... वही आउटपुट।

— शमूएल डेनियलसन

@ क्या आप सुनिश्चित हैं कि यह संकलन नहीं करता है? -> coliru.stacked-crooked.com/a/5aa89a65e3a86c98

— doc

@ डॉक यह सी ++ में संकलित है, लेकिन सी में नहीं।

— फॉर्ड

Answer 6

आईटी इस

#include <stdio.h>
int main(void){
     int x = 10;

     while( x-- > 0 ){ // x goes to 0

       printf("%d ", x);
     }

     return 0;
}

बस अंतरिक्ष चीजों को मज़ेदार, --गिरावट और >तुलना करता है।

Answer 7

के उपयोग की -->ऐतिहासिक प्रासंगिकता है। घटता था (और अभी भी कुछ मामलों में है), x86 आर्किटेक्चर पर वेतन वृद्धि से तेज है। उपयोग करने से -->पता चलता है कि गणितीय पृष्ठभूमि वाले लोगों से अपील की xजा रही है 0।

Comments

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

— burito

खैर, शून्य की ओर घटने का मतलब है कि आपको केवल 0 प्रति पाश पुनरावृत्ति के खिलाफ तुलना करनी होगी, जबकि n की ओर पुनरावृत्ति करना इसका मतलब है कि प्रत्येक पुनरावृत्ति के साथ तुलना करना। पूर्व आसान हो जाता है (और कुछ आर्किटेक्चर पर, प्रत्येक डेटा रजिस्टर ऑपरेशन के बाद स्वचालित रूप से परीक्षण किया जाता है)।

— जॉय एडम्स

@burrito हालांकि मैं असहमत नहीं हूं, गैर-शून्य मूल्यों पर वातानुकूलित छोरों को आमतौर पर पूरी तरह से अनुमानित किया जाता है।

— डंकन

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

— लेगो

बेशक, यह सब इन दिनों लूट है, क्योंकि आधुनिक संकलक स्वचालित रूप से लूपों को वेक्टर और रिवर्स कर सकते हैं।

— लैम्ब्डा फेयरी

Answer 8

while( x-- > 0 )

यह है कि कैसे पार्स किया जाता है।

Answer 9

पूरी तरह से geek, लेकिन मैं इस का उपयोग किया जाएगा:

#define as ;while

int main(int argc, char* argv[])
{
    int n = atoi(argv[1]);
    do printf("n is %d\n", n) as ( n --> 0);
    return 0;
}

Comments

@SAFX - यह इजिप्टियन कोष्ठक के

— mouviciel

यह संकलन नहीं है। C पास्कल नहीं है, जहाँ का आंतरिक do ... whileविवरण सूची है। सी में यह एक ब्लॉक है, इसलिए यह होना चाहिए do { ... } while।

— user207421

@EJP यह संकलन करता है। वाक्य-विन्यास है do statement while ( expression ) ;। ऐसा कहने के बाद, मुझे आशा है कि यह समझ में आ गया है कि मेरा मतलब एक मजाक के रूप में है।

— एस्कुएलो

Answer 10

एक पुस्तक जो मैंने पढ़ी (मुझे ठीक से याद नहीं है कि कौन सी पुस्तक है) में कहा गया है: कंपाइलर बाएं दाएं नियम का उपयोग करके सबसे बड़े टोकन को अभिव्यक्त करने की कोशिश करते हैं।

इस मामले में, अभिव्यक्ति:

x-->0

सबसे बड़े टोकन के लिए पर्स:

token 1: x
token 2: --
token 3: >
token 4: 0
conclude: x-- > 0

इस अभिव्यक्ति पर एक ही नियम लागू होता है:

a-----b

पार्स के बाद:

token 1: a
token 2: --
token 3: --
token 4: -
token 5: b
conclude: (a--)-- - b

मुझे आशा है कि यह जटिल अभिव्यक्ति को समझने में मदद करता है ^ ^

Comments

आपकी दूसरी व्याख्या सही नहीं है। कंपाइलर देखेगा a-----bऔर सोचेगा (a--)-- - b, जो संकलित a--नहीं करता क्योंकि एक लैवल्यू वापस नहीं आता है।

— टिम लीफ

इसके अतिरिक्त, xऔर --दो अलग-अलग टोकन हैं।

— रोलैंड इलिग

@DoctorT: यह लीकर को पार करता है। केवल शब्दार्थ पास ही उस त्रुटि को स्वीकार करने में सक्षम है। इसलिए उसका स्पष्टीकरण सही है।

— v.oddou

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

— बर्नहार्ड बार्कर

@DoctorT उदाहरण सही मान सकते हैं कि aओवरलोडिंग पोस्ट-डेप्रिमेंट ऑपरेटर है, जो कि रिटर्न देता है। coliru.stacked-crooked.com/a/e1effc351ae79e9f

— doc

Answer 11

यह बिल्कुल वैसा ही है

while (x--)
{
   printf("%d ", x);
}

गैर-नकारात्मक संख्या के लिए

Comments

यह नहीं होना चाहिए for(--x++;--x;++x--)?

— मतीन उल्हाक

@DoctorT यही unsignedहै

— कोल जॉनसन

@ मातेनउलहाक, जो कि मानक के अनुसार गलत है, अभिव्यक्ति --x++में World1.9.15 के अनुसार अपरिभाषित व्यवहार है

— WorldSEnder

यदि यह उपयोग कर रहे थे unsigned, तो इसका उपयोग होता%u

— काकाहुइट फ्रिटो

Answer 12

वैसे भी, अब हमारे पास "ऑपरेटर" चला जाता है। "-->"एक दिशा के रूप में याद किया जाना आसान है, और "जबकि x शून्य पर जाता है" अर्थ-सीधा है।

इसके अलावा, यह "for (x = 10; x > 0; x --)"कुछ प्लेटफार्मों की तुलना में थोड़ा अधिक कुशल है ।

Comments

केंट पर जाना हमेशा सही होता है विशेषकर जब x का मान ऋणात्मक हो।

— गणेश गोपालसुब्रमण्यन

दूसरा संस्करण समान कार्य नहीं करता है - for (size_t x=10; x-->0; )लूप के शरीर को 9,8, .., 0 के साथ निष्पादित किया जाता है, जबकि अन्य संस्करण में 10,9, .., 1 है। अन्यथा अप्रकाशित चर के साथ शून्य से नीचे लूप से बाहर निकलना काफी मुश्किल है।

— पीट किर्कम

मुझे लगता है कि यह थोड़ा भ्रामक है ... हमारे पास शाब्दिक रूप से "ऑपरेटर" नहीं है, क्योंकि हमें ++>वृद्धिशील काम करने के लिए दूसरे की आवश्यकता है ।

— tslmy

@ जोश: वास्तव में, अतिप्रवाह के लिए अपरिभाषित व्यवहार होता है int, इसलिए यह आपके कुत्ते को आसानी से खा सकता है जैसे कि xनकारात्मक होने पर शून्य पर ले जाना।

— सामब

यह @PeteKirkham द्वारा कॉमनमेट में दिए गए कारण के लिए मेरे लिए एक बहुत ही महत्वपूर्ण मुहावरा है, क्योंकि मुझे अक्सर सभी तरह से अहस्ताक्षरित मात्रा में घटते छोरों को करने की आवश्यकता होती है 0। (तुलना के लिए, शून्य के लिए परीक्षण छोड़ने की मुहावरे, जैसे कि while (n--)अहस्ताक्षरित के बजाय लेखन n, आप कुछ भी नहीं खरीदते हैं और मेरे लिए पठनीयता में बहुत बाधा डालते हैं।) यह भी सुखद संपत्ति है कि आप प्रारंभिक सूचकांक की तुलना में एक अधिक निर्दिष्ट करते हैं , जो आमतौर पर यही है। आप चाहते हैं (उदाहरण के लिए, एक सरणी पर एक लूप के लिए जो आप इसका आकार निर्दिष्ट करते हैं)। मुझे भी -->बिना स्पेस पसंद है, क्योंकि इससे मुहावरे को पहचानना आसान हो जाता है।

— मार्क वैन लीउवेन 20

Answer 13

यह कोड पहले x और 0 की तुलना करता है और फिर x को घटाता है। (पहले उत्तर में यह भी कहा गया: आप एक्स-डे-रिक्रिएंटिंग x हैं और फिर >ऑपरेटर के साथ x और 0 की तुलना कर रहे हैं ।) इस कोड का आउटपुट देखें:

9 8 7 6 5 4 3 2 1 0

अब हम पहले आउटपुट में 0 को देखकर तुलना करते हैं और फिर घटाते हैं।

अगर हम पहले कमी चाहते हैं और फिर तुलना करते हैं, तो इस कोड का उपयोग करें:

#include <stdio.h>
int main(void)
{
    int x = 10;

    while( --x> 0 ) // x goes to 0
    {
        printf("%d ", x);
    }
    return 0;
}

वह आउटपुट है:

9 8 7 6 5 4 3 2 1

Answer 14

इस कोड को चलाने पर मेरा कंपाइलर 9876543210 प्रिंट करेगा।

#include <iostream>
int main()
{
    int x = 10;

    while( x --> 0 ) // x goes to 0
    {
        std::cout << x;
    }
}

जैसा सोचा था। while( x-- > 0 )वास्तव में इसका मतलब है while( x > 0)। x--पोस्ट decrements x।

while( x > 0 ) 
{
    x--;
    std::cout << x;
}

एक ही बात लिखने का एक अलग तरीका है।

यह अच्छा है कि मूल जैसा दिखता है "जबकि एक्स 0 पर जाता है"।

Comments

परिणाम केवल अपरिभाषित होता है जब आप एक ही चर को एक ही कथन में एक से अधिक बार बढ़ा / घटा रहे होते हैं। यह इस स्थिति पर लागू नहीं होता है।

— टिम लीफ

while( x-- > 0 ) actually means while( x > 0)- मुझे यकीन नहीं है कि आप वहां क्या कहने की कोशिश कर रहे थे, लेकिन जिस तरह से आपने इसका मतलब निकाला है उसका --कोई मतलब नहीं है, जो जाहिर है कि बहुत गलत है।

— बर्नहार्ड बार्कर

@Dukeling से पॉइंट होम ड्राइव करने के लिए, यह उत्तर मूल पोस्ट के समान नहीं है । मूल पोस्ट में, यह लूप छोड़ने के बाद xहोगा -1, जबकि इस उत्तर में, xहोगा 0।

— मार्क लकाटा

Answer 15

वहाँ एक अंतरिक्ष के बीच लापता है --और >। xको पदावनत किया जाता है, अर्थात, स्थिति की जाँच के बाद घटाया जाता है x>0 ?।

Comments

अंतरिक्ष गायब नहीं है - सी (++) व्हाट्सएप की उपेक्षा करता है।

@ H2CO3 यह सामान्य रूप से सही नहीं है। ऐसे स्थान हैं जहां सफेद स्थान का उपयोग टोकन को अलग करने के लिए किया जाना चाहिए, उदाहरण के लिए #define foo()बनाम #define foo ()।

— जेन्स

@ जेन्स के बारे में: "अंतरिक्ष गायब नहीं है - सी (++) अनावश्यक सफेद स्थान की उपेक्षा करता है।"

— केविन पी। राइस

Answer 16

--है घटती ऑपरेटर और >है अधिक से अधिक ऑपरेटर।

दो ऑपरेटरों को एक जैसे एक के रूप में लागू किया जाता है -->।

Comments

वे 2 अलग ऑपरेटरों के रूप में लागू होते हैं। वे केवल "एक एकल" की तरह दिखने के लिए भ्रामक रूप से लिखे गए हैं ।

— अंडरस्कोर_ड

Answer 17

यह दो ऑपरेटरों का एक संयोजन है। पहले --मूल्य >को कम करने के लिए है , और यह जांचने के लिए है कि क्या मूल्य दाहिने हाथ के ऑपरेंड से अधिक है।

#include<stdio.h>

int main()
{
    int x = 10;

    while (x-- > 0)
        printf("%d ",x);

    return 0;
}

उत्पादन होगा:

9 8 7 6 5 4 3 2 1 0            

Answer 18

दरअसल, xपोस्ट-डिक्रिमेंटिंग और उस शर्त के साथ जाँच की जा रही है। यह नहीं है -->, यह नहीं है(x--) > 0

नोट: xस्थिति की जाँच के बाद इसका मूल्य बदल दिया जाता है, क्योंकि यह पोस्ट-डिक्रिमेंटिंग है। कुछ इसी तरह के मामले भी हो सकते हैं, उदाहरण के लिए:

-->    x-->0
++>    x++>0
-->=   x-->=0
++>=   x++>=0

Comments

सिवाय इसके कि ++> थोड़ी देर में () इस्तेमाल किया जा सकता है। एक "ऊपर जाता है ..." ऑपरेटर ++ <होगा, जो कहीं भी अच्छा नहीं दिखता है। संचालक -> एक सुखद संयोग है।

— फ्लोरियन एफ

@BenLeggiero कोड उत्पन्न करने के अर्थ में 'काम' कर सकता है जो कुछ करता है (जबकि पाठकों को जो अशुद्ध-चतुर कोड पसंद नहीं है), लेकिन शब्दार्थ अलग-अलग होते हैं, क्योंकि इसके पूर्व-उपयोग का अर्थ है कि यह एक कम पुनरावृत्ति को अंजाम देगा। एक प्रचलित उदाहरण के रूप में, यह x1 पर शुरू होने पर लूप बॉडी को कभी निष्पादित नहीं करेगा , लेकिन while ( (x--) > 0 )करेगा। {संपादित करें} एरिक लिपर्ट

— ने

Answer 19

C और C ++ "अधिकतम मच" नियम का पालन करते हैं। उसी तरह एक --- बी का अनुवाद किया जाता है (a--) - b, आपके मामले में x-->0अनुवाद करता है (x--)>0।

नियम जो अनिवार्य रूप से कहता है कि बाएं से दाएं जा रहा है, अधिकतम वर्णों को लेकर अभिव्यक्त होते हैं जो एक वैध अभिव्यक्ति का निर्माण करेंगे।

Comments

ओपी ने यह माना है कि: "((ए) ->)" अधिकतम चबाना था। यह पता चलता है कि ओपी की मूल धारणा गलत थी: "->" अधिकतम मान्य ऑपरेटर नहीं है।

— दाविद

लालची पार्सिंग के रूप में भी जाना जाता है, अगर मुझे सही ढंग से याद है।

— रॉय टिंकर

@RoyTinker लालची स्कैनिंग। पार्सर का इससे कोई लेना-देना नहीं है।

— user207421

Answer 20

सारी उलझनें क्यों?

मूल प्रश्न का सरल उत्तर है:

#include <stdio.h>
int main()
{
    int x = 10;
    while (x > 0) 
    {
        printf("%d ", x);
        x = x-1;
    }
}

एक ही काम करता है। यह कहते हुए कि आपको इसे इस तरह करना चाहिए, लेकिन यह एक ही काम करता है और एक पोस्ट में इस सवाल का जवाब देना होगा।

x--इसके बाद के संस्करण के लिए बस आशुलिपि है, और >सिर्फ एक सामान्य अधिक से अधिक है operator। कोई बड़ा रहस्य नहीं!

आजकल बहुत से लोग साधारण चीजों को जटिल बना रहे हैं;)

Comments

यह प्रश्न जटिलताओं के बारे में नहीं है, बल्कि ** छिपी हुई विशेषताओं और C ++ / STL ** के डार्क कॉर्नर ** के बारे में है

— pix

यहाँ प्रोग्राम मूल से भिन्न आउटपुट देता है क्योंकि प्रिंट के बाद x को यहाँ से घटाया जाता है। यह दर्शाता है कि "सरल उत्तर" आमतौर पर गलत कैसे होते हैं।

— 30ö तिएब

The OP's way: 9 8 7 6 5 4 3 2 1 0औरThe Garry_G way: 10 9 8 7 6 5 4 3 2 1

— एंथनी

यह एक ही काम नहीं करता है। अपने हटो x=x-1से पहले printfतो आप कह सकते हैं "यह एक ही बात करता है"।

— CITBL

Answer 21

परंपरागत तरीके से हम whileलूप कोष्ठक में एक स्थिति ()और ब्रेसिज़ के अंदर एक समाप्ति की स्थिति को परिभाषित करेंगे {}, लेकिन -->एक ही बार में दोनों को परिभाषित करते हैं।

उदाहरण के लिए:

int abc(void)
{
    int a = 5
    while((a--) > 0) // Decrement and comparison both at once
    {
        // Code
    }
}

यह घटता है aऔर लूप चलाता है जबकि aइससे अधिक है 0।

परंपरागत रूप से, यह इस तरह होगा:

int abc(void)
{
    int a = 5;
    while(a > 0)
    {
        a--;
        // Code
    }
    a--;
}

दोनों तरीके, हम एक ही काम करते हैं और समान लक्ष्य प्राप्त करते हैं।

Comments

यह गलत है। प्रश्न में कोड है: 'टेस्ट-राइट-एक्ज़ीक्यूट' (पहले टेस्ट करें, नया मान लिखें, लूप निष्पादित करें), आपका उदाहरण 'टेस्ट-एक्ज़्यूट-राइट' है।

— v010dya

@ v010dya ने जवाब तय किया, अब यह test-write-executeसवाल जैसा है, इशारा करने के लिए धन्यवाद!

— कोटसकस

@VladislavToncharov आपका संपादन अभी भी गलत था। मेरा देख लो।

— एसएस ऐनी

Answer 22

(x --> 0) माध्यम (x-- > 0)

1. आप उपयोग कर सकते हैं (x -->)
output -: 9 8 7 6 5 4 3 2 1 0

2. आप उपयोग कर सकते हैं (-- x > 0) यह मतलब है(--x > 0)
output -: 9 8 7 6 5 4 3 2 1

3. आप उपयोग कर सकते हैं

(--\
    \
     x > 0)

output -: 9 8 7 6 5 4 3 2 1

4. आप उपयोग कर सकते हैं

(\
  \
   x --> 0)

output -: 9 8 7 6 5 4 3 2 1 0

5. आप उपयोग कर सकते हैं

(\
  \
   x --> 0
          \
           \
            )

output -: 9 8 7 6 5 4 3 2 1 0

6. आप भी उपयोग कर सकते हैं

(
 x 
  --> 
      0
       )

output -: 9 8 7 6 5 4 3 2 1 0

इसी तरह, आप इस कमांड को सफलतापूर्वक निष्पादित करने के लिए बहुत सारे तरीके आजमा सकते हैं