प्रोटोकॉल ओरिएंटेड प्रोग्रामिंग, भाग 2

विषय की निरंतरता में, हम प्रोटोकॉल प्रकार और सामान्यीकृत कोड की जांच करेंगे।

निम्नलिखित मुद्दों पर विचार किया जाएगा:

• विरासत और संदर्भ प्रकारों के बिना बहुरूपता का कार्यान्वयन
• कैसे प्रोटोकॉल प्रकार वस्तुओं संग्रहीत और उपयोग किया जाता है
• कैसे विधि प्रेषण उनके साथ काम करता है

प्रोटोकॉल प्रकार

विरासत और संदर्भ प्रकारों के बिना बहुरूपता का कार्यान्वयन:

protocol Drawable { func draw() } struct Point: Drawable { var x, y: Int func draw() { ... } } struct Line: Drawable { var x1, x2, y1, y2: Int func draw() { ... } } var drawbles = [Drawable]() for d in drawbles { d.draw() } 

1. ड्रा करने योग्य प्रोटोकॉल को अस्वीकार करें, जिसमें एक ड्रा विधि है।
2. हम इस प्रोटोकॉल को प्वाइंट और लाइन के लिए कार्यान्वित करते हैं - अब आप उन्हें ड्रॉबल के साथ संभाल सकते हैं (ड्रा विधि को कॉल करें)

हमारे पास अभी भी एक बहुरूपी कोड है। ड्रॉइंग एरे के d तत्व में एक इंटरफ़ेस है, जो ड्रॉएबल प्रोटोकॉल में इंगित किया गया है, लेकिन इसके तरीकों के अलग-अलग कार्यान्वयन हैं, जो लाइन और पॉइंट में इंगित किए गए हैं।

बहुरूपता का मुख्य सिद्धांत (तदर्थ): "सामान्य इंटरफ़ेस - कई कार्यान्वयन"

वर्चुअल-टेबल के बिना गतिशील प्रेषण

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

संरचनाओं के मामले में, विरासत, साथ ही तरीकों के पुनर्परिभाषित करना असंभव है। फिर, पहली नज़र में, वर्चुअल-टेबल की कोई आवश्यकता नहीं है, लेकिन फिर गतिशील डिस्पैच काम कैसे करेगा? कोई प्रोग्राम कैसे समझ सकता है कि किस विधि को d.draw () पर बुलाया जाएगा?

यह ध्यान देने योग्य है कि इस पद्धति के कार्यान्वयन की संख्या ड्रॉबल प्रोटोकॉल के अनुरूप प्रकारों की संख्या के बराबर है।

प्रोटोकॉल गवाह तालिका

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

इसके बाद, प्रोटोकॉल गवाह तालिका को "प्रोटोकॉल-विधि तालिका" कहा जाएगा।

ठीक है, अब हम जानते हैं कि विधि कार्यान्वयन के लिए कहां देखना है। केवल दो प्रश्न शेष हैं:

1. इस प्रोटोकॉल को लागू करने वाली वस्तु के लिए उपयुक्त प्रोटोकॉल-विधि तालिका कैसे खोजें? कैसे हमारे मामले में ड्रॉइबल्स सरणी के डी तत्व के लिए इस तालिका को खोजने के लिए?
2. सरणी के तत्व एक ही आकार के होने चाहिए (यह सरणी का सार है)। फिर एक ड्रा करने योग्य सारणी इस आवश्यकता को कैसे पूरा कर सकती है यदि वह इसमें रेखा और बिंदु दोनों को संग्रहीत कर सकती है, और उनके अलग-अलग आकार हैं?

 MemoryLayout.size(ofValue: Line(...)) // 32 bits MemoryLayout.size(ofValue: Point(...)) // 16 bits 

अस्तित्ववादी कंटेनर

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

यह 5 मशीन शब्द लेता है (x64 बिट सिस्टम 5 * 8 = 40 बिट्स में)। इसे तीन भागों में बांटा गया है:

मूल्य बफ़र - उदाहरण के लिए स्वयं स्थान
vwt - सूचक साक्षी तालिका के लिए
pwt - प्रोटोकॉल साक्षी तालिका का सूचक

अधिक विस्तार से सभी तीन भागों पर विचार करें:

सामग्री बफर

एक उदाहरण के भंडारण के लिए सिर्फ तीन मशीन शब्द। यदि उदाहरण सामग्री बफ़र में फिट हो सकता है, तो इसमें संग्रहीत किया जाता है। यदि उदाहरण में 3 से अधिक मशीन शब्द हैं, तो यह बफर में फिट नहीं होगा और प्रोग्राम को ढेर पर मेमोरी आवंटित करने के लिए मजबूर किया गया है, वहां इंस्टेंस डालें और सामग्री बफर में इस मेमोरी को एक पॉइंटर डालें। एक उदाहरण पर विचार करें:

 let point: Drawable = Point(...) 

बिंदु () 2 मशीन शब्दों पर कब्जा कर लेता है और मूल्य बफर में पूरी तरह से फिट बैठता है - कार्यक्रम इसे वहां डाल देगा:

 let line: Drawable = Line(...) 

लाइन () 4 मशीन शब्दों पर कब्जा कर लेता है और एक मूल्य बफर में फिट नहीं हो सकता है - कार्यक्रम ढेर के लिए इसके लिए मेमोरी आवंटित करेगा, और मूल्य बफर में इस मेमोरी में एक पॉइंटर जोड़ें:

ptr एक उदाहरण के लिए लाइन () ढेर पर रखा गया है:

जीवन चक्र तालिका

प्रोटोकॉल-विधि तालिका के साथ-साथ, प्रत्येक तालिका में प्रोटोकॉल होता है। इसमें चार विधियों का कार्यान्वयन शामिल है: आवंटित, प्रतिलिपि, विनाश, डीललोकेट। ये विधियाँ किसी वस्तु के पूरे जीवन चक्र को नियंत्रित करती हैं। एक उदाहरण पर विचार करें:

1. ऑब्जेक्ट (बिंदु (...) को ड्राएबल के रूप में) बनाते समय, T.Zh से आवंटित विधि। यह वस्तु। आवंटित विधि यह तय करेगी कि वस्तु की सामग्री को कहाँ रखा जाना चाहिए (मान बफर में या ढेर पर), और यदि इसे हीप पर रखा जाना चाहिए, तो यह आवश्यक मात्रा में मेमोरी आवंटित करेगा
2. प्रतिलिपि विधि ऑब्जेक्ट की सामग्री को उपयुक्त स्थान पर रखेगी।
3. ऑब्जेक्ट के साथ काम खत्म करने के बाद, विनाश विधि कहा जाएगा, जो सभी लिंक काउंट को कम कर देगा, यदि कोई हो
4. विनाश के बाद, डीललोकेट विधि को बुलाया जाएगा, जो ढेर पर आवंटित स्मृति को मुक्त करेगा, यदि कोई हो

प्रोटोकॉल विधि तालिका

जैसा कि ऊपर वर्णित है, इसमें प्रोटोकॉल के लिए आवश्यक तरीके के कार्यान्वयन शामिल हैं जिनके लिए यह तालिका बाध्य है।

अस्तित्ववादी कंटेनर - उत्तर

इस प्रकार, हमने दो सवालों के जवाब दिए:

1. प्रोटोकॉल-विधि तालिका इस ऑब्जेक्ट के एक्ज़िस्टेंशियल कंटेनर में संग्रहीत होती है और इसे आसानी से प्राप्त किया जा सकता है
2. यदि सरणी का तत्व प्रकार एक प्रोटोकॉल है, तो इस सरणी का कोई भी तत्व 5 मशीन शब्दों का एक निश्चित मूल्य लेता है - यह वही है जो एक अस्तित्ववादी कंटेनर के लिए आवश्यक है। यदि तत्व की सामग्री को मूल्य बफर में नहीं रखा जा सकता है, तो इसे ढेर पर रखा जाएगा। यदि यह हो सकता है, तो सभी सामग्री को मूल्य बफर में रखा जाएगा। किसी भी स्थिति में, हम पाते हैं कि प्रोटोकॉल प्रकार के साथ ऑब्जेक्ट का आकार 5 मशीन शब्द (40 बिट्स) है, और यह निम्नानुसार है कि सरणी के सभी तत्वों का आकार समान होगा।

 let line: Drawable = Line(...) MemoryLayout.size(ofValue: line) // 40 bits let drawables: [Drawable] = [Line(...), Point(...), Line(...)] MemoryLayout.size(ofValue: drawables._content) // 120 bits 

अस्तित्ववादी कंटेनर - उदाहरण

इस कोड में एक अस्तित्वगत कंटेनर के व्यवहार पर विचार करें:

 func drawACopy(local: Drawable) { local.draw() } let val: Drawable = Line(...) drawACopy(val) 

एक अस्तित्ववान कंटेनर को इस तरह दर्शाया जा सकता है:

 struct ExistContDrawable { var valueBuffer: (Int, Int, Int) var vwt: ValueWitnessTable var pwt: ProtocolWitnessTable } 

छद्म कोड

पर्दे के पीछे, ड्रॉस्कोपी फ़ंक्शन ExistContDrawable में लेता है:

 func drawACopy(val: ExistContDrawable) { ... } 

फ़ंक्शन पैरामीटर मैन्युअल रूप से बनाया गया है: एक कंटेनर बनाएं, प्राप्त तर्क से उसके फ़ील्ड भरें:

 func drawACopy(val: ExistContDrawable) { var local = ExistContDrawable() let vwt = val.vwt let pwt = val.pwt local.type = type local.pwt = pwt ... } 

हम तय करते हैं कि सामग्री कहाँ संग्रहीत की जाएगी (बफर या ढेर में)। हम घाटी से स्थानीय सामग्री भरने के लिए vwt.allocate और vwt.copy कहते हैं:

 func drawACopy(val: ExistContDrawable) { ... vwt.allocateBufferAndCopy(&local, val) } 

हम ड्रॉ मेथड को कॉल करते हैं और इसे पॉइंटर टू सेल्फ करते हैं (प्रोजेक्टबफर विधि यह तय करेगी कि स्व कहाँ स्थित है - बफर में या ढेर पर - और सही पॉइंटर लौटाएं):

 func drawACopy(val: ExistContDrawable) { ... pwt.draw(vwt.projectBuffer(&local)) } 

हम स्थानीय के साथ काम खत्म करते हैं। हम स्थानीय से सभी हिप लिंक को साफ करते हैं। फ़ंक्शन एक मान लौटाता है - हम ड्रॉआस्कोपी (स्टैक फ्रेम) के लिए आवंटित सभी मेमोरी को साफ़ करते हैं:

 func drawACopy(val: ExistContDrawable) { ... vwt.destructAndDeallocateBuffer(&local) } 

अस्तित्ववादी कंटेनर - उद्देश्य

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

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

वास्तव में, यह ध्यान रखना महत्वपूर्ण है कि एक संरचना जो एक अस्तित्वगत कंटेनर में संग्रहीत है, चाहे वह स्टैक या हीप पर रखी गई हो, चाहे वह मूल्य प्रकार के शब्दार्थ को बनाए रखेगा। जीवन चक्र सारणी शब्दार्थ के संरक्षण के लिए उत्तरदायी है क्योंकि यह शब्दार्थ निर्धारित करने वाली विधियों का वर्णन करता है।

अस्तित्व कंटेनर - संग्रहीत गुण

हमने जांच की कि कैसे एक प्रोटोकॉल-प्रकार चर एक फ़ंक्शन द्वारा पारित और उपयोग किया जाता है। आइए विचार करें कि ऐसे चर कैसे संग्रहीत किए जाते हैं:

 struct Pair { init(_ f: Drawable, _ s: Drawable) { first = f second = s } var first: Drawable var second: Drawable } var pair = Pair(Line(), Point()) 

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

 pair.second = Line() 

अब, दूसरे की सामग्री को भी ढेर पर रखा गया है, क्योंकि यह बफर पर फिट नहीं था। इस पर विचार करें कि इससे क्या हो सकता है:

 let aLine = Line(...) let pair = Pair(aLine, aLine) let copy = pair 

इस कोड को निष्पादित करने के बाद, कार्यक्रम को निम्नलिखित मेमोरी स्टेटस प्राप्त होगा:

हमारे पास ढेर पर 4 मेमोरी आवंटन हैं, जो अच्छा नहीं है। चलो ठीक करने की कोशिश करते हैं:

1. एक एनालॉग क्लास लाइन बनाएं

 class LineStorage: Drawable { var x1, y1, x2, y2: Double func draw() {} } 

1. हम इसका इस्तेमाल पेयर में करते हैं

 let lineStorage = LineStorage(...) let pair = Pair(lineStorage, lineStorage) let copy = pair 

हम ढेर पर एक प्लेसमेंट और इसके लिए 4 संकेत मिलते हैं:

लेकिन हम संदर्भित व्यवहार के साथ काम कर रहे हैं। कॉपी बदलने से। प्यास जोड़ी को प्रभावित करती है। प्यास (वही। सेकेंड के लिए), जो हमेशा वह नहीं है जो हम चाहते हैं।

अप्रत्यक्ष भंडारण और परिवर्तन पर प्रतिलिपि (कॉपी-ऑन-राइट)

इससे पहले, यह उल्लेख किया गया था कि स्ट्रिंग एक कॉपी-ऑन-राइट संरचना है (ढेर पर अपनी सामग्री को संग्रहीत करता है और इसे बदलने पर इसे कॉपी करता है)। विचार करें कि आप अपनी संरचना को कैसे लागू कर सकते हैं, जिसे बदलते समय कॉपी किया जाता है:

 struct BetterLine: Drawable { private var storage: LineStorage init() { storage = LineStorage((0, 0), (10, 10)) } func draw() -> Double { ... } mutating func move() { if !isKnownUniquelyReferenced(&storage) { storage = LineStorage(self.storage) } // storage editing } } 

1. बेटरलाइन स्टोरेज में सभी गुणों को संग्रहीत करता है, और भंडारण एक वर्ग है और ढेर पर संग्रहीत किया जाता है।
2. स्टोरेज को केवल मूव पद्धति का उपयोग करके बदला जा सकता है। इसमें, हम जांचते हैं कि स्टोरेज के लिए केवल एक पॉइंटर पॉइंट है। यदि अधिक पॉइंटर्स हैं, तो यह बेटरलाइन किसी के साथ भंडारण साझा करता है, और बेटरलाइन के लिए संरचना के रूप में पूरी तरह से व्यवहार करने के लिए, भंडारण को व्यक्तिगत होना चाहिए - हम भविष्य में इसके साथ एक प्रतिलिपि बनाते हैं और काम करते हैं।

आइए देखें कि यह मेमोरी में कैसे काम करता है:

 let aLine = BetterLine() let pair = Pair(aLine, aLine) let copy = pair copy.second.x1 = 3.0 

इस कोड को निष्पादित करने के परिणामस्वरूप, हमें यह मिलता है:

दूसरे शब्दों में, हमारे पास जोड़ी के दो उदाहरण हैं जो समान भंडारण को साझा करते हैं: लाइनस्टोरेज। अपने किसी उपयोगकर्ता (पहले / दूसरे) में स्टोरेज बदलते समय, इस उपयोगकर्ता के लिए स्टोरेज की एक अलग कॉपी बनाई जाएगी ताकि इसका परिवर्तन दूसरों को प्रभावित न करे। यह पिछले उदाहरण से मूल्य प्रकार के शब्दार्थ के उल्लंघन की समस्या को हल करता है।

प्रोटोकॉल प्रकार - सारांश

1. छोटे मूल्य । यदि हम उन वस्तुओं के साथ काम करते हैं जो थोड़ी मेमोरी लेती हैं और उन्हें एक अस्तित्वगत कंटेनर के बफर में रखा जा सकता है, तो:

• ढेर पर कोई प्लेसमेंट नहीं होगा
• कोई संदर्भ गिनती नहीं
• एक प्रोटोकॉल तालिका का उपयोग कर बहुरूपता (गतिशील भेजने)

1. महान मूल्य। यदि हम उन वस्तुओं के साथ काम करते हैं जो बफर में फिट नहीं होते हैं, तो:

• ढेर लगाने का स्थान
• संदर्भ गिनती अगर वस्तुओं में लिंक होते हैं।

परिवर्तन और अप्रत्यक्ष भंडारण के लिए पुनर्लेखन का उपयोग करने के तंत्र का प्रदर्शन किया गया है और उनमें से एक बड़ी संख्या के मामले में संदर्भ गिनती के साथ स्थिति में काफी सुधार कर सकते हैं।

हमने पाया कि प्रोटोकॉल प्रकार, कक्षाओं की तरह, बहुरूपता को महसूस करने में सक्षम हैं। यह एक अस्तित्वगत कंटेनर में भंडारण और प्रोटोकॉल तालिकाओं - जीवन चक्र तालिकाओं और प्रोटोकॉल-विधि तालिकाओं का उपयोग करके होता है।