जवाबों:
निम्नलिखित दो भाव समतुल्य हैं:
a->b
(*a).b
(कोनराड के रूप में ऑपरेटर ओवरलोडिंग के अधीन है, लेकिन यह असामान्य है)।
a[0].b
इसके बजाय भी कर सकते हैं (*a).b
। लेकिन यह ठीक से संरचित नहीं होगा।
a->b
आम तौर पर एक पर्यायवाची है (*a).b
। यहाँ parenthesises आवश्यक ऑपरेटरों के बंधन ताकत की वजह से कर रहे हैं *
और .
: *a.b
काम नहीं होगा क्योंकि .
मजबूत बांधता है और पहले निष्पादित किया जाता है। यह इस प्रकार के बराबर है *(a.b)
।
, अधिक भार से सावधान रहें, हालांकि: चूंकि दोनों ->
और *
अतिभारित किया जा सकता, उनके अर्थ काफी अंतर आ सकता है।
binding strength
ऑपरेटर पूर्वता का मतलब है? यदि नहीं तो दोनों में क्या अंतर है?
C ++ - भाषा तीर संचालक को परिभाषित करती है ( ->
) एक पॉइंटर को .
डीफ़्रैन्फ़ायर करने के लिए एक पर्याय के रूप में और फिर उस पते पर -ओपरेटर का उपयोग करें ।
उदाहरण के लिए:
यदि आपके पास एक ऑब्जेक्ट anObject
और एक पॉइंटर है aPointer
:
SomeClass anObject = new SomeClass();
SomeClass *aPointer = &anObject;
ऑब्जेक्ट्स में से एक का उपयोग करने में सक्षम होने के लिए आप पॉइंटर को डीरेंस करें और उस एड्रेस पर एक मेथड कॉल करें:
(*aPointer).method();
जिसे तीर ऑपरेटर के साथ लिखा जा सकता है:
aPointer->method();
तीर ऑपरेटर के अस्तित्व का मुख्य कारण यह है कि यह एक बहुत ही सामान्य कार्य के टाइपिंग को छोटा करता है और यह पॉइंटर को डेरेफ़रिंग के आसपास के कोष्ठकों को भूल जाना भी आसान है। यदि आप कोष्ठक को भूल गए हैं तो ऑपरेटर मजबूत हो जाएगा और फिर * -ऑपरेटर और हमारे उदाहरण को निष्पादित करेगा:
*(aPointer.method()); // Not our intention!
कुछ अन्य जवाबों में दोनों का उल्लेख भी है कि C ++ ऑपरेटर्स ओवरलोड हो सकते हैं और यह आम नहीं है।
new SomeClass()
एक सूचक ( SomeClass *
) लौटाता है , SomeClass
वस्तु नहीं । और आप घोषणा के साथ शुरू करते हैं anObject
और aPointer
आप p
बाद में उपयोग कर रहे हैं ।
C ++ 0x में, ऑपरेटर को एक दूसरा अर्थ मिलता है, जो फ़ंक्शन या लैम्ब्डा अभिव्यक्ति के रिटर्न प्रकार को दर्शाता है
auto f() -> int; // "->" means "returns ..."
::
वास्तव में एक ऑपरेटर है, जैसे , .
या ->
मानक में "गुंजाइश रिज़ॉल्यूशन ऑपरेटर" कहा जाता है।
->
उस डेटा का उपयोग करते समय उपयोग किया जाता है जिसे आपने एक पॉइंटर को प्राप्त किया है।
उदाहरण के लिए, आप इस तरह के int intar के प्रकार के चर के लिए एक पॉइंटर ptr बना सकते हैं:
int* prt = &intVar;
आप तब किसी फ़ंक्शन का उपयोग कर सकते हैं, जैसे कि foo, उस पर केवल उस सूचक को dereferencing द्वारा - उस चर पर फ़ंक्शन को कॉल करने के लिए, जो सूचक उस चर की स्मृति स्थान के संख्यात्मक मान के बजाय, उस बिंदु पर इंगित करता है:
(*ptr).foo();
यहाँ कोष्ठक के बिना, *(ptr.foo())
संचालक इसे पूर्ववर्ती संज्ञा की वजह से समझेंगे जो कि हम नहीं चाहते।
यह वास्तव में टाइपिंग जैसा ही है
ptr->foo();
के रूप में ->
dereferences कि सूचक, और कॉल समारोह इतना foo()
चर जो सूचक हमारे लिए की ओर इशारा करते है पर।
इसी तरह, हम ->
किसी वर्ग के सदस्य तक पहुँचने या सेट करने के लिए उपयोग कर सकते हैं :
myClass* ptr = &myClassMember;
ptr->myClassVar = 2;
->
कुछ इटैलर प्रकारों के लिए कोई अतिभारित ऑपरेटर नहीं था, इसलिए आपको इसका उपयोग करना था*.
। कई पुस्तकालय उन्हें असंगत रूप से परिभाषित करते हैं। जब आप टेम्प्लेट के साथ काम करते हैं और सटीक प्रकार नहीं जानते हैं तो वास्तव में कष्टप्रद हो जाता है।