संदर्भ द्वारा पास के साथ सी # समर्थन ऑपरेटर ओवरलोडिंग क्यों नहीं करता है?

Question

क्या यह एक सीएलआर प्रतिबंध या भाषा डिजाइन निर्णय है? मैं सी में यह करने की कोशिश की ++/CLI, ज़ाहिर है, जहां यह काम करता है क्योंकि देशी C++ समर्थन करने के लिए जरूरत की:

public ref class Test 
    { 
     public: 
     static Test^ operator &(Test^ msg, int& i) 
     { 
      i = i + 1; 

      return nullptr; 
     } 
    }; 

और फिर संकलक छोड़े गए उत्पादन को देखा:

public: static Test __gc* op_BitwiseAnd(Test __gc* msg, Int32 __gc** modopt(IsImplicitlyDereferenced __gc*) i) 
{ 
    i[0] += 1; 
    return 0; 
} 

मैं आगे चला गया और सी # परियोजना से इस ऑपरेटर कॉल करने की कोशिश - और निश्चित रूप से मैं [असुरक्षित] यह करने के लिए (मैं जरूरत सूचक) जाने के लिए की जरूरत:

Test t = new Test(); 
int i = 0; 

unsafe 
{ 
    t = t & &i; 
} 

जाहिर नहीं इतनी मेहनत CLR के लिए लागू करने के लिए? मैं वास्तव में ऑपरेटर ओवरलोडिंग में संदर्भ से गुजरता हूं और कम से कम खुद को प्रकाश में रखना चाहता हूं कि यह क्यों गुम है?

हमारे ऑपरेटर ओवरलोड में संदर्भ चर के साथ निपटने की आवश्यकता होने पर सी # असुरक्षित और पॉइंटर्स के पीछे कुरूपता क्यों नहीं छिपा सकता है? यहां तक ​​कि अगर मैंने इस बदसूरत कामकाज के साथ जाना चुना है, तो यह सिल्वरलाइट में काम नहीं करेगा, जहां असुरक्षित संचालन की अनुमति नहीं है ...

Answer 1

सी # में, आपके चर को कभी भी संदर्भों के रूप में स्पष्ट रूप से पास किए बिना कैलीज़ द्वारा कभी नहीं बदला जाता है (उदाहरण के लिए int.TryParse(s, out i) जहां आप स्पष्ट रूप से out कीवर्ड निर्दिष्ट करते हैं)। यह सुविधा ओवरलोडेड ऑपरेटर को आपकी स्पष्ट अनुमति के बिना ऑपरेटरों की सामग्री को बदलने की अनुमति देकर जटिल बनाती है।

उदाहरण के लिए

,

public static MyStruct operator + (ref MyStruct left, ref MyStruct right) { 
    left = new MyStruct(); // !!!!!!!! 
    return something(left, right); 
} 

आप सी # में इस तरह के एक ऑपरेटर संदर्भ जब:

MyStruct x = new MyStruct(); 
MyStruct y = new MyStruct(); 
MyStruct z = x + y; // in C#, you never expect `x` to be changed. 

Answer 2

मुझे लगता है कि यह है एक ऑपरेटर (अधिक गणितीय दृश्य सी # लेने के लिए लगता है कि में) है, क्योंकि तर्कसंगत रूप से कुछ जो अपने तर्कों को एक नए मूल्य में जोड़ता है, कभी भी कुछ भी उत्परिवर्तित नहीं होना चाहिए। सी ++ विशेष रूप से गणित का प्रतिनिधित्व करने के तरीके के रूप में, कार्यों की तुलना में अधिक सुविधाजनक वाक्यविन्यास के साथ ऑपरेटर को सामान्य संचालन के संस्करण के रूप में अधिक मानता है। मुझे लगता है कि सी # में आप धारा संचालन के लिए ऑपरेटरों को परिभाषित करने जैसी चीजें कभी नहीं देख पाएंगे।