(अनुवाद) स्काला में ओवरलोडिंग ऑपरेटर

एक लंबे समय के लिए तर्क दे सकता है कि क्या ओवरलोड ऑपरेटरों की क्षमता एक विशेष भाषा का एक मजबूत या कमजोर पक्ष है। लेकिन तथ्य यह है कि - स्काला में ऐसा अवसर है। तो इसका उपयोग क्यों नहीं करते?

लेख की सामग्री मुख्य रूप से शुरुआत करने वाले स्काला डेवलपर्स के लिए डिज़ाइन की गई है।

संचालक अधिभार

तो क्या वास्तव में ऑपरेटर ओवरलोडिंग है?
सामान्य तौर पर, ऑपरेटर परिचित "+", "-", "*", "हैं!" और कई अन्य। इसके अलावा, कभी-कभी एक ही ऑपरेटर अलग-अलग व्यवहार कर सकता है, जो इस बात पर निर्भर करता है कि यह किसके साथ संचालित होता है (उदाहरण के लिए, पूर्णांक के योग के रूप में और + स्ट्रिंग संयोजन ऑपरेशन के रूप में)। ऑपरेटर ओवरलोडिंग का विचार सरल है - यदि ऑपरेटर का व्यवहार उन वस्तुओं के वर्ग के आधार पर बदलता है, जिसके साथ वह काम करता है, तो विशेष रूप से आपके वर्ग के लिए उसके लिए नए व्यवहार को परिभाषित क्यों नहीं किया जाता है?

एक मिनट रुको! लेकिन उन्होंने मुझे बताया कि ओवरलोडिंग ऑपरेटरों की बुराई है!

ओवरलोडिंग ऑपरेटर एक विवादास्पद विषय है। यह अक्सर कहा जाता है कि यह कई गालियों का कारण है, और यह सुविधा सी ++ में बदली गई थी ताकि जावा भाषा के रचनाकारों ने जानबूझकर इसे छोड़ दिया (स्ट्रिंग को छिपाने के लिए + ऑपरेटर के अपवाद के साथ)।

मेरी राय थोड़ी अलग है। यदि आप उचित जिम्मेदारी के साथ ऑपरेटरों के अधिभार से संपर्क करते हैं, तो आप महत्वपूर्ण व्यावहारिक लाभ निकाल सकते हैं। मैं आपको एक उदाहरण देता हूं: कई वस्तुओं को एक साथ जोड़ा या जोड़ा जा सकता है, इसलिए केवल "+" ऑपरेटर का उपयोग क्यों न करें?

मान लीजिए आपने जटिल संख्याओं के लिए एक वर्ग लिखा है, और आप चाहते हैं कि जटिल संख्याएँ जोड़ी जाएँ। निम्नलिखित कोड लिखना अधिक सुखद नहीं है:

Complex result = complex1 + complex2;
... और ...
Complex result = complex1.add(complex2);

पहली पंक्ति अधिक प्राकृतिक लगती है, है ना?

तो, क्या स्काला ऑपरेटरों को ओवरलोड होने की अनुमति देती है?

वास्तव में नहीं। अधिक ठीक है, नहीं।

यह पता चला है कि इससे पहले कि मैं जो कुछ भी पढ़ता हूं वह बकवास है? यह सबसे बेवकूफ लेख मैंने कभी पढ़ा है! मुझे स्काला से नफरत है। बेहतर Algol 68 पर प्रोग्रामिंग जारी रखें।

मैं बस एक सेकंड के लिए पूछूंगा, मैं अभी तक नहीं किया गया। स्काला ओवरलोडिंग के लिए ऑपरेटर का समर्थन नहीं करता है, क्योंकि स्काला के पास बस नहीं है!

स्काला में कोई ऑपरेटर नहीं हैं? तुम पागल हो! इसलिए कई बार मैंने "सम = 2 + 3" जैसा कुछ लिखा! लेकिन सूची में "::" और ": /" के संचालन के बारे में क्या? वे ऑपरेटरों की तरह दिखते हैं!

काश, वे नहीं होते। पूरे बिंदु यह है कि स्काला के लिए सख्त आवश्यकताएं नहीं हैं जिन्हें एक विधि कहा जा सकता है।

जब आप निम्नलिखित कोड लिखते हैं:

sum = 2 + 3
..., वास्तव में, आप उदाहरण के RichInt वर्ग में + के मान के साथ + विधि कहते हैं। आप अंतिम पंक्ति को भी फिर से लिख सकते हैं:
sum = 2.+(3)
... अगर आप वास्तव में चाहते हैं।

हाँ। अब मैं समझ गया। तो क्या आप मुझे वहाँ पर ओवरलोडिंग करने वाले ऑपरेटर के बारे में बताना चाहते हैं?

यह बहुत सरल है - एक नियमित विधि का वर्णन करने के रूप में सरल है। मैं एक उदाहरण दूंगा।

 class Complex(val real : Double, val imag : Double) { def +(that: Complex) = new Complex(this.real + that.real, this.imag + that.imag) def -(that: Complex) = new Complex(this.real - that.real, this.imag - that.imag) override def toString = real + " + " + imag + "i" } object Complex { def main(args : Array[String]) : Unit = { var a = new Complex(4.0,5.0) var b = new Complex(2.0,3.0) println(a) // 4.0 + 5.0i println(a + b) // 6.0 + 8.0i println(a - b) // 2.0 + 2.0i } } 

यह सब शांत है, लेकिन क्या होगा अगर मैं ऑपरेटर को "नहीं" ("!") को फिर से परिभाषित करना चाहता हूं?

इस ऑपरेटर और "+" और "-" ऑपरेटरों के बीच अंतर यह है कि यह एकात्मक और उपसर्ग है। लेकिन स्काला भी "+" जैसे इन्फिक्स ऑपरेटरों की तुलना में अधिक सीमित रूप में इस तरह का समर्थन करता है।

सीमित रूप से मेरा तात्पर्य इस तथ्य से है कि केवल 4 को एकीकृत उपसर्ग ऑपरेटरों को फिर से परिभाषित किया जा सकता है: "+", "-", "!" और "~"। ऐसा करने के लिए, आपको कक्षा में unary_!, Unary_ ~, आदि उपयुक्त विधियों को परिभाषित करने की आवश्यकता है।

निम्न उदाहरण दिखाता है कि जटिल संख्या के लिए ~ ऑपरेटर को कैसे परिभाषित किया जाए, जो इस संख्या के मापांक को लौटाता है:

 class Complex(val real : Double, val imag : Double) { // ... def unary_~ = Math.sqrt(real * real + imag * imag) } object Complex { def main(args : Array[String]) : Unit = { var b = new Complex(2.0,3.0) prinln(~b) // 3.60555 } } 

निष्कर्ष में

जैसा कि आप देख सकते हैं, स्काला में ओवरलोडिंग ऑपरेटर बहुत सरल हैं। लेकिन कृपया इस अवसर का बुद्धिमानी से उपयोग करें । एक कक्षा में "+" जैसी विधियों को परिभाषित न करें, जब तक कि आपकी कक्षा कुछ ऐसा न कर सके जिसे व्याख्या या जोड़ के रूप में समझा जा सके।

मूल लेख - टॉम जेफरी, स्काला में "ऑपरेटर ओवरलोडिंग"