सी # मध्ये, संदर्भ प्रकार वि आदिमांसह == ऑपरेटर कसे कार्य करते यामध्ये काय फरक आहे?


उत्तर 1:

जावा प्रमाणेच: == आदिमसाठी मूल्ये तुलना करते, संदर्भासाठी पॉईंटर्सची तुलना करते. मुळात ==, जोपर्यंत ओव्हरलोड स्टॅकवर संग्रहित मूल्यांची तुलना करत नाही, जर आपल्याला स्ट्रिंग सारख्या संदर्भ डेटा प्रकारांची तुलना करायची असेल तर आपल्याला पद्धत वापरावी लागेल .एक्वल्स () हे तेह ढीगवर संग्रहित सामग्रीची तुलना करेल.


उत्तर 2:

सर्व संदर्भ प्रकार समर्थन == तुलना: ओव्हरलोड नसल्यास ऑपरेटर संदर्भ समानता तपासणी करेल. एखाद्या प्रकारासाठी ओव्हरलोड असल्यास ते त्या प्रकाराद्वारे परिभाषित केल्यानुसार मूल्य समानता तपासणी करेल. उदाहरणार्थ सी # मध्ये (जावा विपरीत) कामगिरी == तारांवर मूल्य तुलना करते; विशेषत :, ते एक सामान्य मूल्य तुलना करते, म्हणजे केस-सेन्सेटिव्ह, संस्कृती-असंवेदनशील वर्ण-दर-वर्ण तुलना.

आदिम मूल्य प्रकारांमध्ये तयार केलेल्या == अपेक्षित (फ्लोट आणि डबल, विशेषत: एनएएन सह सावधगिरी बाळगा) मूल्य समानता पूर्ण करते. वापरकर्त्याने परिभाषित मूल्य प्रकारांमध्ये == आणि! = परिभाषित करणे आवश्यक आहे किंवा अशी तुलना असमर्थित असेल. सर्वसाधारणपणे, बर्‍याच स्ट्रक््ट्ससाठी जिथे आपण समानतेची तुलना करू इच्छित आहात.

  • परिभाषित करा == आणि! = ओव्हरराइड इक्वल (ऑब्जेक्ट) ओव्हरराइड गेटहेशकोड () आयकॅटेबल अंमलात आणा आणि सर्व पूर्वगामी असे की प्रत्येक पद्धत इतरांसह सुसंगत परिणाम प्रदान करते

उत्तर 3:

सी # मध्ये, आदिमांची तुलना करणे त्यांच्या मूल्यांची तुलना करेल, संदर्भ प्रकारांची तुलना केल्यास rheir संदर्भांची तुलना केली जाईल (डीफॉल्टनुसार). संदर्भ प्रकाराचा अर्थ असा आहे की 2 वस्तूंची तुलना करून, जोपर्यंत तो तंतोतंत सारखा नसतो (समान संदर्भ) तो समान होणार नाहीः

वर्ग व्यक्ती
{
  सार्वजनिक स्ट्रिंगचे नाव {get;
  
  सार्वजनिक व्यक्ती (तार्याचे नाव)
  {
    नाव = नाव;
  }
}

आम्ही एकाच नावाने 2 लोक तयार करतो. त्यांचे संदर्भ भिन्न असतील, cparisom चा परिणाम चुकीचा होईल.

var a = नवीन व्यक्ती ("टॉम");
var बी = नवीन व्यक्ती ("टॉम");

var areEqual = a == b; // खोटे

तथापि, आपण ओव्हरराइडिंग == ऑपरेटरद्वारे डीफॉल्ट वर्तन अधिलिखित करू शकता:

वर्ग व्यक्ती
{
  सार्वजनिक स्ट्रिंगचे नाव {get;
  
  सार्वजनिक व्यक्ती (तार्याचे नाव)
  {
    नाव = नाव;
  }

  सार्वजनिक स्थिर बूल ऑपरेटर == (व्यक्ती पी 1, व्यक्ती पी 2)
  {
    जर (ऑब्जेक्ट. संदर्भ संदर्भ (p1, शून्य)
    {
      जर (ऑब्जेक्ट. संदर्भ संदर्भ (p2, शून्य)
      {
        खरे परत येणे;
      }
    }

    // आता आपल्याला माहित आहे की डावे शून्य नाही आम्ही मूल्यांची तुलना करू शकतो
    हे परत करा.एक्विल्स (पी 2);
  }

  सार्वजनिक स्थिर बूल ऑपरेटर! = (व्यक्ती पी 1, व्यक्ती पी 2) =>! (पी 1 == पी 2);

  पब्लिक बूल इक्वेल्स (ऑब्जेक्ट पी)
  {
    // उजव्या बाजूला मूल्य आहे की नाही ते तपासा.
    जर (ऑब्जेक्ट. संदर्भ संदर्भ (पी, शून्य)
    {
      खोटे परत येणे;
    }

    // या टप्प्यावर आमच्याकडे डीफॉल्ट == अंमलबजावणी आहे.

    // दोन्ही संदर्भ समान आहेत म्हणजे समान मूल्यांसह समान वस्तू.
    जर (ऑब्जेक्ट. संदर्भ संदर्भ (हे, पी)
    {
      खरे परत येणे;
    }
    
    // प्रकार अचूक जुळणे आवश्यक आहे.
    जर (हे.गेटटाइप ()! = पी. गेटटाइप ())
    {
      खोटे परत येणे;
    }
    
    // शेवटी आपण प्रत्येक ऑब्जेक्टची सामग्री तुलना करू शकतो.
    हे परत करा.एक्वेल्स (पी. नेम);
  }
}

जर आपण या दोघांची पुन्हा तुलना केली तर निकाल बरोबर होईल.

var a = नवीन व्यक्ती ("टॉम");
var बी = नवीन व्यक्ती ("टॉम");

var areEqual = a == b; // खरे