दिलचस्प पोस्ट
एसएसआरएस 2008 आर 2 – एसएसआरएस 2012 – रिपोर्ट वीवर: सफारी और क्रोम में रिपोर्ट रिक्त हैं कैसे एकाधिक रिकॉर्ड डालें और पहचान मूल्य प्राप्त करें? डुप्लिकेट डिक्ट इन पायथन में सूची निकालें टाइप करें java.lang.CharSequence पैकेज घोषणा में हल नहीं किया जा सकता जावास्क्रिप्ट ऑब्जेक्ट में मुख्य लुकअप का प्रदर्शन टर्मिनल में जीआईटी स्टेटस की सूची से कैसे बाहर निकलना है? स्टैकलेस भाषा कैसे काम करती है? बेस्ट प्रैक्टिस: सल्टिंग एंड पेपरिंग पासवर्ड? नल मॉडल के साथ प्रस्तुत करना गलत प्रकार से पारित हो जाता है एक डेटाबेस से कनेक्शन स्ट्रिंग कैसे प्राप्त करें डॉट (।) का मतलब क्या आरआईटी आरआईएल में है? OpenSSL के लिए grep या .jar फ़ाइलों को कैसे खोजें? एक गो प्रोग्राम में स्थिर संसाधनों का बंडल करने का सबसे अच्छा तरीका क्या है? प्रतिगमन कैफ के लिए टेस्ट लेबल, फ्लोट की अनुमति नहीं है? SQL सर्वर में दी गई तालिका को संदर्भित करने वाली सभी विदेशी कुंजीओं को कैसे सूचीबद्ध कर सकता हूं?

मुझे `यह` सूचक का स्पष्ट उपयोग कब करना चाहिए?

मुझे एक वर्ग की किसी विधि में this->member को स्पष्ट रूप से लिखना चाहिए?

वेब के समाधान से एकत्रित समाधान "मुझे `यह` सूचक का स्पष्ट उपयोग कब करना चाहिए?"

आमतौर पर, आपको ऐसा करने की आवश्यकता नहीं है, this-> निहित है

कभी-कभी, एक नाम अस्पष्टता है, जहां इसका उपयोग वर्ग के सदस्यों और स्थानीय चर को अलग करने के लिए किया जा सकता है। हालांकि, यहां एक बिल्कुल अलग मामला है this-> स्पष्ट रूप से आवश्यक है

निम्नलिखित कोड पर विचार करें:

 template<class T> struct A { int i; }; template<class T> struct B : A<T> { int foo() { return this->i; } }; int main() { B<int> b; b.foo(); } 

यदि आप this-> करते हैं, तो कंपाइलर i नहीं समझता कि i कैसे इलाज कर सकता i , क्योंकि यह A सभी तत्त्वों में मौजूद या हो सकता है। यह बताने के लिए कि i वास्तव में A<T> का सदस्य हूं, किसी भी T , this-> उपसर्ग की आवश्यकता है

नोट: यह अब भी इसे छोड़कर संभव this-> उपसर्ग का उपयोग करके:

 template<class T> struct B : A<T> { using A<T>::i; // explicitly refer to a variable in the base class int foo() { return i; // i is now known to exist } }; 

यदि आप एक मौजूदा सदस्य के रूप में एक नाम के साथ एक स्थानीय चर की घोषणा करते हैं, तो आपको स्थानीय- चर के बजाय क्लास सदस्य तक पहुंचने के लिए इस-> var का उपयोग करना होगा।

 #include <iostream> using namespace std; class A { public: int a; void f() { a = 4; int a = 5; cout << a << endl; cout << this->a << endl; } }; int main() { A a; af(); } 

प्रिंट:

5
4

ऐसे कई कारण हैं कि आपको this सूचक को स्पष्ट रूप से उपयोग करने की आवश्यकता क्यों हो सकती है

  • जब आप अपने ऑब्जेक्ट के संदर्भ को कुछ फ़ंक्शन पर पास करना चाहते हैं।
  • जब सदस्य ऑब्जेक्ट के समान नाम से स्थानीय रूप से घोषित ऑब्जेक्ट होता है
  • जब आप निर्भर आधार कक्षाओं के सदस्यों तक पहुंचने का प्रयास कर रहे हैं
  • कुछ लोग अपने कोड में सदस्य पहुंच को दर्शाने के लिए नेत्रहीन रूप से संकेत देते हैं।
  1. जहां एक सदस्य चर एक स्थानीय चर द्वारा छुपाया जाएगा
  2. यदि आप इसे स्पष्ट रूप से स्पष्ट करना चाहते हैं कि आप एक उदाहरण विधि / चर बुला रहे हैं

कुछ कोडिंग मानक दृष्टिकोण (2) का उपयोग करते हैं क्योंकि उनका दावा है कि यह कोड को पढ़ने में आसान बनाता है।

उदाहरण:
मान लें कि MyClass के पास एक सदस्य चर है जिसे 'गिनती' कहा जाता है

 void MyClass::DoSomeStuff(void) { int count = 0; ..... count++; this->count = count; } 

एक अन्य मामला तब होता है जब ऑपरेटरों को लगाया जाता है। उदाहरण के बजाय

 bool Type::operator!=(const Type& rhs) { return !operator==(rhs); } 

तुम कह सकते हो

 bool Type::operator!=(const Type& rhs) { return !(*this == rhs); } 

जो अधिक पठनीय हो सकता है दूसरा उदाहरण कॉपी और स्वैप है:

 Type& Type::operator=(const Type& rhs) { Type temp(rhs); temp.swap(*this); } 

मैं नहीं जानता कि यह swap(temp) क्यों नहीं लिखा है, लेकिन यह आम बात है

हालांकि मैं आमतौर पर इसे पसंद नहीं करता हूं, मैंने देखा है कि दूसरों ने इसे-> बस intellisense से सहायता प्राप्त करने के लिए उपयोग किया है!

ऐसे कुछ मामलों में जहां इसका उपयोग this जाना चाहिए, और अन्य ऐसे भी हैं जहां this संकेतक का उपयोग करना समस्या को हल करने का एक तरीका है।

1) उपलब्ध विकल्प : लोकल वैरिएबल और क्लास सदस्यों के बीच अस्पष्टता को हल करने के लिए, जैसा कि @ एसएके द्वारा सचित्र है

2) कोई वैकल्पिक नहीं: किसी सदस्य फ़ंक्शन से एक पॉइंटर या संदर्भ वापस करने के लिए। operator+ , operator- , operator= , आदि से अधिक भार करते समय यह अक्सर (और किया जाना चाहिए) किया जाता है:

 class Foo { Foo& operator=(const Foo& rhs) { return * this; } }; 

ऐसा करने से " विधि चेनिंग " नामक मुहावरे की अनुमति दी जाती है, जहां आप किसी एक ऑब्जेक्ट पर कोड की एक पंक्ति में कई कार्य करते हैं। जैसे कि:

 Student st; st.SetAge (21).SetGender (male).SetClass ("C++ 101"); 

कुछ इस सलाह पर विचार करते हैं, अन्य लोग इसे घृणित मानते हैं। बाद के समूह में मुझे गिनें

3) कोई वैकल्पिक नहीं: निर्भर प्रकारों में नामों को हल करने के लिए टेम्पलेट का उपयोग करते समय, इस उदाहरण के रूप में यह आता है:

 #include <iostream> template <typename Val> class ValHolder { private: Val mVal; public: ValHolder (const Val& val) : mVal (val) { } Val& GetVal() { return mVal; } }; template <typename Val> class ValProcessor : public ValHolder <Val> { public: ValProcessor (const Val& val) : ValHolder <Val> (val) { } Val ComputeValue() { // int ret = 2 * GetVal(); // ERROR: No member 'GetVal' int ret = 4 * this->GetVal(); // OK -- this tells compiler to examine dependant type (ValHolder) return ret; } }; int main() { ValProcessor <int> proc (42); const int val = proc.ComputeValue(); std::cout << val << "\n"; } 

4) उपलब्ध विकल्प: कोडिंग शैली का एक भाग के रूप में, दस्तावेजों के लिए जो वेरिएबल सदस्य चर हैं जो कि स्थानीय चर के विपरीत हैं। मैं एक अलग नामकरण योजना पसंद करता हूं जहां सदस्य varibales को स्थानीय लोगों के समान नाम नहीं मिल सकता है। वर्तमान में मैं सदस्यों के लिए mName का उपयोग कर रहा हूँ और स्थानीय लोगों के लिए name

आपको इसका उपयोग पैरामीटर / लोकल वैरिएबल और सदस्य वैरिएबल के बीच की अवहेलना करने के लिए करना this

 class Foo { protected: int myX; public: Foo(int myX) { this->myX = myX; } }; 

आपको केवल-> का उपयोग करना होगा यदि आपके पास दो संभावित नामस्थानों में समान नाम वाला प्रतीक है उदाहरण के लिए:

 class A { public: void setMyVar(int); void doStuff(); private: int myVar; } void A::setMyVar(int myVar) { this->myVar = myVar; // <- Interesting point in the code } void A::doStuff() { int myVar = ::calculateSomething(); this->myVar = myVar; // <- Interesting point in the code } 

कोड में दिलचस्प बिंदुओं पर, myVar का संदर्भ स्थानीय (पैरामीटर या चर) myVar को देखेंगे क्लास सदस्य को मेरीवर्टर भी कहा जाने के लिए, आपको स्पष्ट रूप से "this->" का उपयोग करने की आवश्यकता है

इसके लिए अन्य उपयोग (जैसा कि मैंने सोचा था कि जब मैंने सारांश और आधे प्रश्न पढ़ा है …), अन्य उत्तरों में निरंकुश नामकरण का नामकरण (बुरा), यदि आप वर्तमान ऑब्जेक्ट डालना चाहते हैं, तो इसे फ़ंक्शन ऑब्जेक्ट में बाँध लें या इसे एक सूचक-से-सदस्य के साथ उपयोग करें

निर्मोक

 void Foo::bar() { misc_nonconst_stuff(); const Foo* const_this = this; const_this->bar(); // calls const version dynamic_cast<Bar*>(this)->bar(); // calls specific virtual function in case of multi-inheritance } void Foo::bar() const {} 

बाइंडिंग

 void Foo::baz() { for_each(m_stuff.begin(), m_stuff.end(), bind(&Foo:framboozle, this, _1)); for_each(m_stuff.begin(), m_stuff.end(), [this](StuffUnit& s) { framboozle(s); }); } void Foo::framboozle(StuffUnit& su) {} std::vector<StuffUnit> m_stuff; 

ptr करने वाली सदस्य

 void Foo::boz() { bez(&Foo::bar); bez(&Foo::baz); } void Foo::bez(void (Foo::*func_ptr)()) { for (int i=0; i<3; ++i) { (this->*func_ptr)(); } } 

उम्मीद है कि यह सिर्फ इस-> सदस्य से इसके अन्य उपयोगों को दिखाने में मदद करता है

कुछ लोग this बारे में बात कर रहे थे कि this कैसे संदर्भ होना चाहिए और मैं और अधिक सहमत नहीं हो सकता। मैं बस कहना चाहूंगा कि प्रीकॉम्प्लर की एक बदसूरत रेखा यह अनुकरण कर सकती है कि:

 #define self (*this) 

इसका प्रयोग न करें 🙂

मुझे प्रभावी सी ++ पुस्तक में "इस" सूचक का स्पष्ट उपयोग करने का एक और रोचक मामला मिला।

उदाहरण के लिए, कहते हैं कि आपके पास एक const समारोह है

  unsigned String::length() const 

आप प्रत्येक कॉल के लिए स्ट्रिंग की लंबाई की गणना नहीं करना चाहते हैं, इसलिए आप ऐसा कुछ कैशिंग करना चाहते हैं

  unsigned String::length() const { if(!lengthInitialized) { length = strlen(data); lengthInitialized = 1; } } 

लेकिन यह संकलन नहीं करेगा – आप किसी const समारोह में ऑब्जेक्ट को बदल रहे हैं।

इस को सुलझाने की चाल को यह एक गैर-कॉन्स्ट को ढका देना है:

  String* const nonConstThis = (String* const) this; 

फिर, आप ऊपर में करने में सक्षम होंगे

  nonConstThis->lengthInitialized = 1; 

this सूचक का मुख्य (या मैं कह सकता हूँ, केवल) उद्देश्य this है कि यह किसी सदस्य फ़ंक्शन को आमंत्रित करने के लिए इस्तेमाल किए गए ऑब्जेक्ट को इंगित करता है।

इस उद्देश्य पर आधार, हमारे पास कुछ ऐसे मामले हो सकते हैं जो केवल this संकेतक का उपयोग करके समस्या को हल कर सकते हैं।

उदाहरण के लिए, हमें एक फ़ंक्शन के साथ सदस्य फ़ंक्शन में आने वाले ऑब्जेक्ट को एक समान वर्ग ऑब्जेक्ट में वापस करना होगा:

 class human { ... human & human::compare(human & h){ if (condition) return h; // argument object else return *this; // invoking object } };