🕥 📿 🚶🏿 प्रोग्रामिंग भाषा डी

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

तो, इस विषय की बारीकियां ऐसी हैं कि कम शब्द और अधिक काम होंगे, क्योंकि परिचय छोटा होगा:
D में, C ++ की तरह ऑपरेटर, विशेष कार्यों को ओवरलोड करके लोड होते हैं, हालांकि, C ++ और C # के विपरीत, यहां फ़ंक्शन विशेष नहीं हैं, लेकिन काफी सामान्य नाम हैं।

हम पहले बहुभुज को परिभाषित करके शुरू करेंगे, इस उद्देश्य के लिए मैंने जटिल संख्याओं के वर्ग को चुना है।
तो:

import std.stdio; import std.math; //    . struct Complex { private: double re; double im; public: //        this(double r = 0, double i = 0) { re = r; im = i; } @property nothrow pure double Re() { return re; } @property nothrow pure double Im() { return im; } @property nothrow pure double Abs() { return sqrt(re ^^ 2 + im ^^ 2); } @property nothrow pure double Arg() { return atan(im/re); } }

यहां कई जटिल संख्याएं और उनके रूप लिखे गए हैं, हालांकि, जैसा कि हम सभी सामान्य बीजगणित के पाठ्यक्रम से जानते हैं, उन पर संचालन के साथ-साथ विचार करने के लिए सेट बहुत उपयोगी होते हैं। तो, हम किस तरह के ऑपरेशन देखना चाहते हैं?
पहले, हम निश्चित रूप से इन नंबरों की तुलना करने में सक्षम होना चाहेंगे। अच्छा, अच्छा, एक अच्छा लक्ष्य, इसे प्राप्त करने का प्रयास करें। डी में, तुलना ऑपरेटर opEquals द्वारा निर्दिष्ट किया गया है।
थोड़ा आगे देखना: सामान्य तौर पर, डी में सभी ऑपरेटर ओप फ़ंक्शन ओवरलोड के साथ ओवरलोड होते हैं। मैं लेख में सभी अतिभारित ऑपरेटरों को कवर करने का प्रयास करूंगा।
तो तुलना:

 pure nothrow bool opEquals(Complex v) { return v.re == re && v.im == im; }

और सफलता के लिए हमारे प्रयासों की जाँच करें:

 unittest { Complex a, b; assert(a == b); assert(!(a != b)); // ,   ? }

हां, D काफी स्मार्ट है और जानता है कि a! = B एक ही जैसा है! (A == b), इसलिए ऑपरेटर को परिभाषित करने की कोई आवश्यकता नहीं है! =
अब opcmp विधि का उपयोग करके जटिल संख्याओं की तुलना करने की इच्छा को महसूस करने के लिए एक तार्किक निरंतरता होगी:

 pure nothrow int opCmp(Complex v) { auto a = Abs; auto va = v.Abs; if(a == va) return 0; else if(a > va) return 1; else return -1; }

और हम अपने unittest के पूरक हैं:

 Complex a, b, c = 1; // ,   ? assert(a == b); assert(!(a != b)); assert(a >= b); assert(c >= b);

अब मैं समझाता हूँ। हां, मेरे लिए इस कोड को स्वयं लिखना दर्द रहित था। क्योंकि यह तुलना केवल गणितीय रूप से गलत है - यह आवश्यक स्वयंसिद्धों को संतुष्ट नहीं करता है।
दूसरी ओर, मैंने> ऑपरेटर का उपयोग नहीं किया, लेकिन केवल> =, इसलिए मैंने इसे जटिल संख्याओं के सेट पर आंशिक गैर-सख्त आदेश मानने का फैसला किया। डी, ज़ाहिर है, स्वयंसिद्धों की जांच नहीं करेगा, इसलिए> ऑपरेटर का उपयोग अभी भी भाषा के दृष्टिकोण से सही है, लेकिन गणित।
अब, बहाना खत्म हो गया है, अब हमें यह स्पष्ट करने की आवश्यकता है कि भाषा स्वचालित रूप से कोड उत्पन्न करती है जो आपको अभिव्यक्ति c = 1. लिखने की अनुमति देती है और जब से मैं फ़ील्ड के क्रम को {re, im} के रूप में निर्धारित करूंगा, यह असाइनमेंट ठीक वही परिणाम देगा जिसकी मुझे उम्मीद है - पहला क्षेत्र 1 सौंपा जाएगा।
बस के मामले में, मैं स्पष्ट रूप से नोटिस करूंगा: opCmp की परिभाषा एक बार में एक नहीं, बल्कि चार तुलना ऑपरेटरों का उपयोग करना संभव बनाती है। यह मेरे लिए C ++ की तुलना में अधिक सुविधाजनक है, लेकिन यह स्वाद की बात है।
अब हमें जटिल मान निर्दिष्ट करने की आवश्यकता है, इसके लिए हम opAssign को अधिभारित करेंगे:

 ref Complex opAssign(Complex v) { re = v.re; im = v.im; return this; }

मैंने विशेष समानता, आदेश और कॉपी ऑपरेटरों पर विचार किया, अब मैं अधिक सामान्य अंकगणितीय ऑपरेटरों की ओर बढ़ूंगा। आइए शुरुआत करते हैं। यहाँ डी हमें एक सुखद आश्चर्य के साथ प्रस्तुत करता है: ऑपरेटर कार्यों के एक समूह को याद करने की कोई आवश्यकता नहीं है, सभी एकात्मक ऑपरेटरों को एक फ़ंक्शन द्वारा परिभाषित किया जाता है: T.opUnary (string op) ();
मैं एक उदाहरण के साथ समझाऊंगा:

 ref Complex opUnary(string op)() if (op == "++") { ++re; return this; } ref Complex opUnary(string op)() if (op == "--") { --re; return this; } Complex opUnary(string op)() if (op == "-") { return Complex(-re, -im); } Complex opUnary(string op)() if (op == "+") { return Complex(re, im); } bool opUnary(string op)() if (op == "!") { return !re && !im; }

और यहाँ काम का एक उदाहरण है:

 unittest { Complex a, b, c = 1; assert(a == b); assert(!(a != b)); assert(a >= b); assert(c >= b); auto d = ++c; d = c++; // ,  ? d--; //   ? a = -d; b = +d; assert(d == Complex(1, 0) && c == Complex(3, 0)); assert(b == d && a == Complex(-1, 0)); }

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

 ref Complex opUnary(string op)() if (op == "++" || op == "--") { mixin(op ~ "re;"); return this; } Complex opUnary(string op)() if (op == "+" || op == "~") { return Complex(mixin(op ~ "re"), mixin(op ~ "im")); }

कलाई की एक झटका के साथ, चार विधियाँ दो में बदल जाती हैं! हमने मूल रूप से एक टेम्पलेट का वर्णन किया है जिसमें हम ऑपरेटर के नाम को "मिक्स" करते हैं। कुछ भी आसान नहीं है!
खैर, आगे बढ़ते हैं। अधिक सटीक रूप से, हम अपने जटिल अंकगणित के विवरण को जारी रखते हैं - अब हमें बाइनरी ऑपरेटरों की आवश्यकता है।
जैसा कि सभी ने शायद अनुमान लगाया है, बाइनरी ऑपरेटरों को एक ही सिद्धांत पर बनाया गया है जैसे कि एक: वे सभी एक ही कार्य T.opBinary (string op) (V a) द्वारा परिभाषित किए गए हैं।
मैं लेख को नहीं बढ़ाऊंगा और तुरंत मिक्सचर एक्सप्रेशन का उपयोग करके उन्हें परिभाषित करूंगा:

 Complex opBinary(string op)(Complex v) if (op == "-" || op == "+") { return Complex(mixin("v.re" ~ op ~ "re"), mixin("v.im" ~ op ~ "im")); } Complex opBinary(string op)(Complex v) if (op == "*") { return Complex(re*v.re - im*v.im, im*v.re + re*v.im); } Complex opBinary(string op)(Complex v) if (op == "/") { auto r = v.Abs; return Complex((re*v.re + im*v.im) / r, (im*v.re - re*v.im) / r); } //    ,    Complex opBinary(string op)(int v) if (op == "^^") { Complex r = Complex(re, im), t = r; //    opAssign foreach(i; 1..v) r = r * t; return r; }

और यहाँ एक उदाहरण (यद्यपि स्पष्ट) उपयोग का है:

 unittest { Complex a, b, c = 1; a = 1; b = Complex(0, 1); d = a + b; auto k = a * b; auto p = c ^^ 3; assert(d == Complex(1, 1) && k == Complex(0, 1)); assert(p == Complex(27, 0)); }

यह भी संभव है कि ऑपरेटर%, >>, <<, >>>, &,;, ^, को सामान्य अर्थ के साथ परिभाषित करें, लेकिन फ़्लोटिंग पॉइंट नंबरों के मेरे उपयोग के कारण यह थोड़ा समझ में आता है, और ऑपरेटर ओवरलोडिंग की तकनीक में कुछ नया नहीं लाता है।
थोड़ा अधिक है, मैंने एक पूर्णांक तक के ऑपरेटर को परिभाषित किया है, लेकिन कोड की एक स्पष्ट अधिकता है। स्थिति को थोड़ा ठीक करने के लिए, मुझे * = ऑपरेटर की आवश्यकता होती है, जो कि उन सभी के समान है, इसे opOpAssign (हाँ, इस तरह की एक तनातनी) के रूप में परिभाषित किया गया है।

 ref Complex opOpAssign(string op)(Complex v) if (op == "-" || op == "+" || op == "*" || op == "/") { auto t = Complex(re, im); mixin("auto r = t" ~ op ~ "v;"); re = r.re; im = r.im; return this; } Complex opBinary(string op)(int v) if (op == "^^") { Complex r = Complex(re, im), t = r; //    opAssign foreach(i; 1..v) r *= t; return r; }

यह केवल उस स्थिति से निपटने के लिए रहता है जब कॉम्प्लेक्स चर बाईं तरफ नहीं है, लेकिन दाईं ओर इस तरह है:

 Complex a = 1; Complex b = 5 * a;

मैं इस कोड का सही संचालन करना चाहूंगा। चाहते हैं - कृपया! सभी बाइनरी ऑपरेटरों का एक विशेष, दाहिने हाथ वाला संस्करण है, यह आमतौर पर कम्यूटेटिविटी द्वारा निर्धारित करना सबसे आसान है:

 Complex opBinaryRight(string op)(double v) if(op == "+" || op == "*") { return Complex.opBinary!op(v); }

और अगर ऑपरेशन सराहनीय नहीं है, तो आप प्रत्यक्ष प्रकार के रूपांतरण का उपयोग कर सकते हैं:

 Complex opBinaryRight(string op)(double v) if(op == "-" || op == "/") { return Complex.opBinary!op(Complex(v,0)); }

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

 double opCast(T)(int v) if (is(T == double)) { if(im != 0) throw new Exception("Not real!"); return re; }

रूपांतरण ऑपरेटर के साथ एक और अच्छा बिंदु जुड़ा हुआ है। अर्थात्, "अगर (expr)" और "expr? a: b? "क्रमशः" if (कास्ट (bool) expr) "और" cast (bool) expr के रूप में क्रमशः रूपांतरित होता है। a: b; ”। इसका लाभ लें:

 double opCast(T)(int v) if (is(T == bool)) { return re == 0 && im == 0; }

अब हम जैसे भाव लिख सकते हैं:

 Complex a = 0; if(!a) return false;

यह अनुक्रमण ऑपरेशन के अधिभार को दिखाने का समय है। दुर्भाग्य से हमारे कॉम्प्लेक्स वर्ग पर यह थोड़ा अजीब लगेगा, लेकिन यह सिर्फ एक उदाहरण है, है ना?
अनुक्रमण दो प्रकार के हो सकते हैं: पढ़ना और लिखना। वे क्रमशः opIndex और opIndexAssign द्वारा दर्शाए गए हैं। आइए उन्हें लागू करने का प्रयास करें:

 double opIndex(size_t a) { switch(a) { case 1: return Re; case 2: return Im; default: throw new Exception("Ur doin it wrong."); } } void opIndexAssign(double v, size_t a) { switch(a) { case 1: re = v; break; case 2: im = v; break; default: throw new Exception("Ur doin it wrong."); } } // , ,   ,   -  : a[1,2] = 0 // re = 0, im = 0 void opIndexAssign(double v, size_t a, size_t b) { switch(a) { case 1: re = v; break; case 2: im = v; break; default: throw new Exception("Ur doin it wrong."); } switch(b) { case 1: re = v; break; case 2: im = v; break; default: throw new Exception("Ur doin it wrong."); } }

सब कुछ तार्किक है, लेकिन अगर हम अचानक ऐसा कोड लिखना चाहते हैं तो क्या होगा:

 Complex a = 0; a[1] += 1;

C ++ में, opIndex Ref रेफरी है, वहां सब कुछ स्पष्ट है, लेकिन यहां? और यहाँ अनुक्रमणिका संचालक का एक विशेष रूप है: opIndexAssignUnary (string op) (v, i)

 void opIndexAssignUnary(string op)(double v, size_t a) { switch(a) { case 1: mixin("re " ~ op ~ "= v"); break; case 2: mixin("im " ~ op ~ "= v"); break; default: throw new Exception("Ur doin it wrong."); } }

आइए कोशिश करते हैं:

 unittest { ... assert(p == Complex(27, 0)); p[0] /= 3; assert(p == Complex(9, 0)); }

इस विषय पर, डी सरणियों के "स्लाइस" का समर्थन करता है और आम तौर पर एक [n..k] (के शामिल नहीं है) के साथ मनमाना डेटा संरचनाओं, जहां n, कश्मीर किसी भी अभिव्यक्ति है जिसमें, इसके अलावा, आप विशेष वर्ण $ का उपयोग कर सकते हैं, जो सरणी की लंबाई का प्रतीक है।
इस प्रकार, डी ऑपरेटरों का समर्थन करता है: opSlice, जो रेंज लौटाता है, और opDollar, जिसका उपयोग स्लाइस एक्सप्रेशन में किया जा सकता है। इसी तरह, अगर opSilceAssign और opSliceOpAssign ऑपरेटर्स का इंडेक्सर्स के एनालॉग्स के समान अर्थ है।
मैं उन्हें नहीं लाया, क्योंकि इसके लिए हमें एक नए प्रशिक्षण ग्राउंड और कोड का एक गुच्छा चाहिए, और लेख पहले ही समाप्त हो चुका है, जल्द ही नहीं होगा, तो चलिए आगे बढ़ते हैं।

हर कोई जानता है कि आधुनिक भाषाओं में (सी ++ में भी नकल है) एक फॉर्च्यूनर ऑपरेटर है - एक संग्रह पर पुनरावृत्ति का एक सुरक्षित एनालॉग। C ++ में इसका उपयोग करने के लिए आपको इट्रेटर इंटरफ़ेस लागू करना होगा। C # में समान। डी के पास एक ही अवसर है: एक सरल इंटरफ़ेस लागू करें:

  { @property bool empty(); // - iterator != end() @property ref T front(); // - begin() void popFront(); // - next()  iterator++ }

हालांकि, उपरोक्त भाषाओं के विपरीत, डी एकमात्र संभावना नहीं है। यदि आपने इस इंटरफ़ेस को लागू करने की कोशिश की, उदाहरण के लिए, एक पेड़ के लिए, तो आप जानते हैं कि यह किस तरह का रक्तस्राव है, इसलिए डी बस स्थिति को बचाता है!
यहां आप फ़ॉरेस्ट लूप के शरीर के प्रसंस्करण को संग्रह में पास कर सकते हैं। यह न केवल एक पेड़ के लिए पॉपफ्रॉस्ट () के लिए एक टैम्बोरिन के साथ नृत्य करने से बचाता है, बल्कि पूरी तरह से एनकैप्सुलेशन की भावना का अनुपालन करता है।
सब कुछ कैसा चल रहा है? और यहां बताया गया है: फ़ॉरेस्ट बॉडी को एक प्रतिनिधि में लपेटा जाता है और संबंधित ऑब्जेक्ट विधि में पास किया जाता है।
एक नया परीक्षण करने के लिए कक्षा में बहुत अधिक जगह होगी, इसलिए भले ही मैं जोखिम से गुजर रहा हो, मुझे खेद है, एक विकृत, मैं अभी भी इस अवधारणा को अपने जटिल नंबरों पर प्रदर्शित करने का प्रयास करता हूं। बस इसे घर पर दोहराने की कोशिश न करें!

 int opApply(int delegate(ref double) f) { auto res = f(re); if(res) return res; res = f(im); return res ? res : 0; }

मुझे आश्चर्य है कि क्या हुआ?

 auto p = Complex(10,5); foreach(i; p) writeln(i);

प्रदर्शित करता है:
10
5

महान, सही? खासकर यदि आप कल्पना करते हैं कि आप एक पेड़ लिख रहे हैं, और इस अवसर का उपयोग अपने इच्छित उद्देश्य के लिए कर रहे हैं ...
लेकिन क्या आपको लगता है कि यह वास्तव में अच्छा अवसर है? और नहीं! आगे बेहतर है।
मैं वास्तव में माफी मांगता हूं, लेकिन निम्नलिखित पुस्तक से लगभग शब्दशः एक उदाहरण होगा - मैंने ईमानदारी से कोशिश की, लेकिन अधिक प्रभावशाली उदाहरण के साथ नहीं आ सका।
पहले लेख से प्रोटोटाइप विरासत याद है? तो अब एक पूर्ण, पूरी तरह से गतिशील प्रोटोटाइप विरासत होगा।
और इसे एक सांख्यिकीय रूप से टाइप की गई भाषा में कैसे प्राप्त किया जाए? डॉट ऑपरेटर को ओवरलोड करके! हां, हां, अन्य भाषाओं के विपरीत D, यह संभव है।
और वेरिएंट प्रकार हमें इसमें मदद करेगा। तो:

 import std.variant; //   ,         . alias Variant delegate(DynamicObj self, Variant[]args...) DynamicMethod; //   -   class DynamicObj { private Variant[string] fields; private DynamicMethod[string] methods; void AddMethod(string name, DynamicMethod f) { methods[name] = f; } void RemoveMethod(string name) { methods.remove(name); } //   Variant opDispatch(string name, Args)(Args args...) { Variant[] as = new Variant[args.length]; foreach(i, arg; args) as[i] = Variant(arg); return methods[name](this, args); } Variant opDispatch(string name)() { return fields[name]; } }

और इसका उपयोग करने का प्रयास करें:

 unittest { auto obj = new Dynamic; DynMethod ff = cast(DynMethod) (Dynamic, Variant[]) { writeln("Hello, world!"); return Variant(); }; obj.AddMethod("sayHello", ff); obj.sayHello(); }

आउटपुट: नमस्ते, दुनिया!

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

प्रोग्रामिंग भाषा डी - 2 जारी रखा

More articles: