डॉट (।) ऑपरेटर और -> सी ++ में अंतर क्या है?

Question

डॉट (।) ऑपरेटर और -> सी ++ में अंतर क्या है?

Answer 1

. ऑपरेटर प्रत्यक्ष सदस्य पहुंच के लिए है।

object.Field 

तीर तो तुम,

pClass->Field 

Answer 2

तीर ऑपरेटर डॉट की तरह है करने के लिए वस्तु/स्मृति यह इंगित कर रहा है उपयोग कर सकते हैं, सिवाय इसके कि यह एक सूचक पहले dereferences एक सूचक dereferences। foo.bar() कॉल foo द्वारा ऑब्जेक्ट पर ऑब्जेक्ट पर foo, foo->bar कॉल विधि bar पर विधि bar() कॉल विधि bar पर कॉल करें।

Answer 3

-> जब आपके पास सूचक है तो इसका उपयोग करें। जब आपके पास स्ट्रक्चर (क्लास) है, तो जब आप संरचना उपयोग से संबंधित बिंदु विशेषता चाहते हैं तो इसका उपयोग करें। structure.attribute जब चाहते श्रेय देने के लिए मुद्दा यह है कि सूचक उपयोग के द्वारा स्मृति के लिए संदर्भ है ->:

pointer->method; 
or same as: 
(*pointer).method 

Answer 4

लक्ष्य। डॉट वस्तुओं पर काम करता है; तीर ऑब्जेक्ट्स पर पॉइंटर्स पर काम करता है।

std::string str("foo"); 
std::string * pstr = new std::string("foo"); 

str.size(); 
pstr->size(); 

Answer 5

डॉट ऑपरेटर ओवरलोड नहीं किया जा सकता है, तीर ऑपरेटर ओवरलोड हो सकता है। तीर ऑपरेटर आमतौर पर पॉइंटर्स (या ऑब्जेक्ट्स जो पॉइंटर्स की तरह व्यवहार करते हैं, जैसे स्मार्ट पॉइंटर्स) पर लागू होते हैं। डॉट ऑपरेटर पॉइंटर्स पर लागू नहीं किया जा सकता है।

संपादित जब सूचक तीर ऑपरेटर के लिए आवेदन किया pointee को (ptr-> क्षेत्र के लिए (* ptr) .field बराबर है) डॉट ऑपरेटर को लागू करने के बराबर है

Answer 6

foo->bar()(*foo).bar() के समान है।

* और . ऑपरेटरों की बाध्यकारी शक्ति के कारण उपरोक्त कोष्ठक आवश्यक है। क्योंकि डॉट (.) ऑपरेटर पहले मूल्यांकन किया जाता है

*foo.bar() कार्य नहीं करेगा (operator precedence देखें)

डॉट (.) ऑपरेटर अतिभारित नहीं किया जा सकता, तीर (->) ऑपरेटर अतिभारित किया जा सकता।

डॉट (.) ऑपरेटर पॉइंटर्स पर लागू नहीं किया जा सकता है।

यह भी देखें: What is the arrow operator (->) synonym for in C++?

Answer 7

pSomething->someMember 

(*pSomething).someMember 

Answer 8

यह आसान है के बराबर है, जब भी आप देख

x->y 

पता है कि यह

(*x).y 

रूप में ही है

Answer 9

द। (डॉट) ऑपरेटर आमतौर पर कक्षा के उदाहरण (या एक स्थिर क्षेत्र/कक्षा के तरीके) से एक विधि/कॉल विधि प्राप्त करने के लिए प्रयोग किया जाता है।

p.myField, p.myMethod() -> (तीर) ऑपरेटर एक क्षेत्र मिल/वर्ग द्वारा बताया सामग्री से एक विधि कॉल करने के लिए किया जाता है - एक वर्ग

के पी उदाहरण।

p-> myField, p-> MyMethod() -> ऑपरेटर कुछ चीजें के लिए इस्तेमाल किया जा सकता है, उदाहरण के लिए, ऑपरेटर [] तक पहुँचने - एक वर्ग

Answer 10

ध्यान दें कि करने के लिए पी अंक।

#include <vector> 

int main() 
{ 
    std::vector<int> iVec; 
    iVec.push_back(42); 
    std::vector<int>* iVecPtr = &iVec; 

    //int i = iVecPtr->[0]; // Does not compile 
    int i = (*iVecPtr)[0]; // Compiles. 
} 

Answer 11

-> एक संकेतक भिन्नता के लिए बस वाक्यात्मक चीनी,

के रूप में अन्य लोगों ने कहा है:

pointer-> विधि();

कह का एक सरल विधि है:

(* सूचक) .method();

अधिक सूचक मस्ती के लिए, अपसंदर्भन की Binky, और अपने जादू की छड़ी की जाँच:

http://www.youtube.com/watch?v=UvoHwFvAvQE

Answer 12

एक सूचक के लिए, हम सिर्फ

*pointervariable.foo 

इस्तेमाल कर सकते हैं लेकिन . ऑपरेटर अधिक से अधिक है * ऑपरेटर की तुलना में प्राथमिकता, इसलिए . का मूल्यांकन पहले किया गया है। इसलिए हम कोष्ठक के साथ इस के लिए मजबूर करने की जरूरत है:

(*pointervariable).foo 

लेकिन टाइपिंग() का हर समय कठिन है, इसलिए वे एक ही बात कहने के लिए एक शॉर्टकट के रूप -> विकसित की है। आप एक वस्तु या वस्तु संदर्भ का एक संपत्ति एक्सेस कर रहे हैं, . का उपयोग आप एक सूचक के माध्यम से किसी वस्तु की संपत्ति एक्सेस कर रहे हैं, का उपयोग ->

Answer 13

दोनों के बीच अंतर यह है कि सरल है "->" एक सूचक से पहले dereferences यह उन वस्तुओं के फ़ील्ड, फ़ंक्शन इत्यादि को देखने के लिए जाता है जबकि "।" पहले dereference नहीं है। जब आपके पास ऑब्जेक्ट में पॉइंटर होता है, तो "->" का प्रयोग करें, और "।" जब आप किसी ऑब्जेक्ट के वास्तविक उदाहरण के साथ काम कर रहे हों।

यह संकेत देने का एक और समकक्ष तरीका पहले सूचक पर "*" dereferencing का उपयोग करना होगा और फिर "।" का उपयोग करें। हम "->" का उपयोग कर बिचौलियों को छोड़ देते हैं।

अन्य मतभेद हैं, लेकिन अन्य उत्तरों ने इसे व्यापक रूप से कवर किया है।

यदि आपके पास जावा में पृष्ठभूमि है तो यह आपको भ्रमित कर सकता है, क्योंकि जावा में, सबकुछ पॉइंटर्स है। इसका मतलब है कि प्रतीक होने का कोई कारण नहीं है जो आपके पॉइंटर को पहले से कम नहीं करता है। सी ++ में हालांकि आपको यह याद रखने के साथ थोड़ा और सावधान रहना होगा कि क्या पॉइंटर नहीं है, और यह उपसर्ग "पी_" या बस "पी" के साथ लेबल करना एक अच्छा विचार हो सकता है।

Answer 14

-> ऑपरेटर का उपयोग तब किया जाता है जब हम एक पॉइंटर के साथ काम कर रहे होते हैं और डॉट अन्यथा उपयोग किया जाता है। तो अगर हम की तरह एक struct वर्ग है:

struct class{ int num_students; int yr_grad; }; 

और हम एक वर्ग * curr_class (कक्षा सूचक) का एक उदाहरण है, तो हम क्या करेंगे छात्रों की संख्या तक पहुंचने के लिए

cout << curr_class->num_students << endl; 

मामले में हम एक सरल वर्ग वस्तु था, कहते हैं कि class_2016, हम

cout << class_2016.num_students << endl; 

करना होगा वर्ग के लिए सूचक के लिए -> ऑपरेटर

के बराबर है

(*obj).mem_var 

नोट: एक वर्ग के लिए, वर्ग के सदस्य फ़ंक्शन तक पहुंचने के लिए रास्ता भी उसी तरह