ऑपरेटर ओवरलोडिंग में

ऑपरेटर ओवरलोडिंग के बारे में

आप अपनी ही क्लासों और स्ट्रक्टों में इस्तेमाल के लिए गणित और तुलना के मुख्य ऑपरेटरों को ढाल सकते हैं। इसे ही ऑपरेटर ओवरलोडिंग कहते हैं।

यह लेख सिंटैक्स की विस्तृत चर्चा करता है, और यह भी बताता है कि कौन-से ऑपरेटर ओवरलोड किए जा सकते हैं और कौन-से नहीं।

अधिकतर ऑपरेटरों का रूप ऐसा होता है:

static <return type> operaator <operator symbols>(<parameters>);

कास्ट ऑपरेटरों का रूप ऐसा होता है:

static (explicit|implicit) operator <cast-to-type>(<cast-from-type> <parameter name>);

ऑपरेटर static मेथड्स की ही तरह व्यवहार करते हैं।

• ऑपरेटर का चिह्न मेथड के आइडेंटिफायर की जगह लेता है, और ऑपरेटरों के पैरामीटर तथा एक रिटर्न टाइप होता है। पैरामीटरों और रिटर्न टाइप के टाइप नियम आपकी सहज समझ के अनुसार होते हैं, और आप भरोसा रख सकते हैं कि कंपाइलर विस्तृत मार्गदर्शन देगा।
• बाइनरी ऑपरेशनों में पहला पैरामीटर ऑपरेशन के बाएँ तरफ वाला आर्गुमेंट लेता है।
• बाइनरी ऑपरेशनों के मामले में ऑपरेटर के सिग्नेचर में दो पैरामीटर और एक रिटर्न टाइप होते हैं, जबकि यूनरी ऑपरेटरों के मामले में एक पैरामीटर और एक रिटर्न टाइप।
• बाइनरी ऑपरेटरों के लिए, पैरामीटर टाइपों में से एक उसी क्लास का टाइप होना चाहिए जिसमें ऑपरेटर घोषित किया गया है।
• टाइप कन्वर्ज़न के मामले में या तो पैरामीटर या रिटर्न टाइप उसी क्लास का टाइप होना चाहिए जिसमें ऑपरेटर घोषित किया गया है।
• बढ़ाने और घटाने वाले ऑपरेटरों के लिए पैरामीटर और रिटर्न टाइप दोनों उसी क्लास के टाइप होने चाहिए जिसमें ऑपरेटर घोषित किया गया है।

सिंटैक्स के उदाहरण:

struct Point
{
    decimal x;
    decimal y;

    public static bool operator ==(Point pt, Point ptOther)
    {
        return pt.x == ptOther.x && pt.y == ptOther.y;
    }

    public static bool operator !=(Point pt, Point ptOther)
    {
        return !(pt == ptOther);
    }

    public static Point operator *(Point pt, decimal scale)
    {
        var ptNew = new Point();
        ptNew.x = pt.x * scale;
        ptNew.y = pt.y * scale;
        return ptNew;
    }

    public static implicit operator Point((decimal x, decimal y) xy)
    {
        var pt = new Point();
        pt.x = xy.x;
        pt.y = xy.y;
        return pt;
    }

    public static explicit operator (decimal x, decimal y)(Point pt)
    {
        return (pt.x, pt.y);
    }
}

अक्सर यह कारगर होता है कि आप Equals() मेथड लागू कीजिए और उसे == ऑपरेटर से कॉल कीजिए। इसी तरह, तुलना के लिए आप IComparable इंटरफेस लागू कर सकते हैं। दोनों ही मामलों में आप एक ही तीर से दो शिकार कर लेते हैं।

ध्यान दीजिए कि आप ऐसे चिह्नों से ऑपरेटर नहीं बना सकते जो ऑपरेटरों के मानक समूह का हिस्सा न हों। आप केवल उन्हीं ऑपरेशनों के लिए मौजूद चिह्नों का उपयोग कर सकते हैं जिनके बारे में डॉक्युमेंटेशन बताता है कि उन्हें ओवरलोड किया जा सकता है। जिन ऑपरेटरों को ओवरलोड किया जा सकता है, उनकी सूची यहाँ दी गई है।

ध्यान रखिए कि जहाँ पैरामीटरों के टाइप अलग-अलग हों, वहाँ उनका क्रम मायने रखता है। ऊपर दिए उदाहरण कोड में pt * 10m एक मान्य एक्सप्रेशन है, जबकि 10m * pt कंपाइल नहीं होगा।

संदर्भ

ऑपरेटर ओवरलोडिंग का यह डॉक्युमेंटेशन सिंटैक्स के बारे में विस्तार से बताता है।