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




operators code-formatting standards-compliance (18)

comp.lang.c++.moderated पर सी ++ / एसटीएल की छिपी हुई विशेषताएं और डार्क कॉर्नर पढ़ने के बाद 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);
    }
}

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


Answers

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

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

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


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

#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            

while( x-- > 0 )

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


ध्यान दें

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

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

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

while((x--) > 0)

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

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


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

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

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

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


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


यह कोड पहले x और 0 की तुलना करता है और फिर x को कम करता है। (पहले जवाब में भी कहा गया है: आप x-postmenting 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

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

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


यह बराबर है

while (x-- > 0)

x-- (पोस्ट कमी) x = x-1 बराबर है, इसलिए कोड इस प्रकार बदल जाता है:

while(x > 0) {
    x = x-1;
    // logic
}

जब मैं इस कोड को चलाता हूं तो मेरा कंपाइलर 9876543210 प्रिंट करेगा।

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

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

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

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

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

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


परंपरागत तरीके से हम लूप कोष्ठक " () " और ब्रेसिज़ के अंदर स्थिति को समाप्त करने के दौरान स्थिति को परिभाषित करते हैं, लेकिन यह -- & > एक तरीका है जो सभी को एक साथ परिभाषित करता है। उदाहरण के लिए:

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

यह कहता है, जब तक 0 से अधिक समय तक लूप को कम करें और चलाएं

अन्य तरीकों से यह होना चाहिए था:

int abc(){
    int a = 5
    while(a > 0){
        // Code
        a = a -1 // Decrement inside loop
    }
}

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


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

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

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

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

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


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

;)


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

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


सभी जटिलताओं क्यों?

मूल प्रश्न का सरल जवाब सिर्फ है:

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

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

x-- उपर्युक्त के लिए सिर्फ लघुरूप है, और > operator तुलना में बस सामान्य है। कोई बड़ा रहस्य नहीं!

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


एक गोचा यह है कि निम्नलिखित कार्यान्वयन निर्भर है (एएनएसआई मानक के अनुसार):

char x = -1;
x >> 1;

एक्स अब 127 (01111111) या अभी भी -1 (11111111) हो सकता है।

अभ्यास में, यह आमतौर पर उत्तरार्द्ध है।





c++ operators code-formatting standards-compliance