क्या एक OOP भाषा है?

ऑब्जेक्ट-ओरिएंटेड डिज़ाइन कंप्यूटिंग का रोमन अंक है।

- रोब पाइक, गो के लेखक।







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

1. परिचय

तो "वस्तु उन्मुख" होने का क्या मतलब है? आइए OOP की अवधारणा के इतिहास को देखें, यह जानने की कोशिश करें।

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



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



चूंकि ओओपी की कोई सार्वभौमिक रूप से स्वीकृत परिभाषा नहीं है, हम चर्चा जारी रखने के लिए अपना स्वयं का प्रारूप तैयार करेंगे।

प्रोग्राम टेक्स्ट में स्पष्ट रूप से कोड और डेटा को अलग करने के बजाय, एक ऑब्जेक्ट-ओरिएंटेड सिस्टम उन्हें "ऑब्जेक्ट" की अवधारणा का उपयोग करके जोड़ती है। ऑब्जेक्ट एक अमूर्त डेटा प्रकार है जिसमें राज्य (डेटा) और व्यवहार (कोड) शामिल हैं।

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



इसके बाद, हम देखेंगे कि कैसे गो वस्तुओं, बहुरूपता और वंशानुक्रम का उपयोग करता है, जिसके बाद प्रश्न का उत्तर देना आसान हो जाएगा।

2. वस्तुएं?

Go in object



नाम की कोई चीज नहीं है, हालांकि यह महत्वपूर्ण नहीं है। टाइप object



न मिलने दें, लेकिन एक प्रकार है जो ऑब्जेक्ट-ओरिएंटेड दृष्टिकोण की परिभाषा के अंतर्गत आता है - डेटा संरचनाएं जिनमें राज्य और व्यवहार दोनों शामिल हैं, उन्हें struct



रूप में दर्शाया जाता है। संरचना एक प्रकार है जिसमें नामित फ़ील्ड और विधियाँ हैं।



स्पष्टता के लिए, मैं एक उदाहरण दूंगा:

 type rect struct { width int height int } func (r *rect) area() int { return r.width * r.height } func main() { r := rect{width: 10, height: 5} fmt.Println("area: ", r.area()) }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

पहला ब्लॉक एक नए प्रकार के संरचनात्मक प्रकार को परिभाषित करता है जिसमें 2 पूर्णांक फ़ील्ड होते हैं। अगला ब्लॉक इस संरचना पर एक विधि को परिभाषित करता है जो area



फ़ंक्शन को परिभाषित करता है और इसे rect



प्रकार में संलग्न करता है। अधिक सटीक रूप से, वास्तव में, फ़ंक्शन पॉइंटर प्रकार से जुड़ा हुआ है।

अंतिम ब्लॉक प्रोग्राम एंट्री पॉइंट है, यह मुख्य कार्य है। पहली पंक्ति एक नई आवृत्ति का निर्माण करती है (एक यौगिक बनाने का चुना हुआ तरीका - एक यौगिक शाब्दिक के माध्यम से - गो में सबसे सुविधाजनक है)। दूसरी पंक्ति r



के मान पर फ़ंक्शन area



को कॉल करने के परिणामों को आउटपुट करने के लिए जिम्मेदार है।



व्यक्तिगत रूप से, यह सब मुझे वस्तुओं के साथ काम करने की बहुत याद दिलाता है। मैं एक प्रकार का संरचित डेटा बना सकता हूं और उनमें से कुछ के साथ काम करने के तरीकों को परिभाषित कर सकता हूं।

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

2. विरासत और बहुरूपता

वस्तुओं के बीच संबंधों को परिभाषित करने के लिए कई अलग-अलग दृष्टिकोण हैं। हालांकि कुछ अंतर हैं, वे सभी लगभग एक ही उद्देश्य के लिए उपयोग किए जाते हैं - कोड के पुन: उपयोग के लिए।



2.1। सरल और कई विरासत

वंशानुक्रम एक भाषा तंत्र है जो आपको एक मौजूदा (आधार) वर्ग के आधार पर एक नए वर्ग का वर्णन करने की अनुमति देता है। बेस कक्षाओं की संख्या के आधार पर, विरासत की दो किस्में हैं। एकाधिक वंशानुक्रम के उपयोग के परिणामों का मूल्यांकन करके ही मूलभूत अंतर को महसूस किया जा सकता है: एकल वंशानुक्रम एक पेड़ है, जबकि एकाधिक वंशानुक्रम एक जाली उत्पन्न करता है। बेहद सरल समर्थन करने वाली भाषाओं में PHP, C #, Java और रूबी शामिल हैं, जबकि कई भाषाएं जो कई विरासतों का समर्थन करती हैं, उनमें पर्ल, पायथन और C ++ शामिल हैं।



2.2। उपप्रकार बहुरूपता

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



यह स्पष्ट रूप से कार्यान्वयन के माध्यम से विरासत और "विरासत" के माध्यम से उप-वर्गों के बहुरूपता के बीच स्पष्ट रूप से अंतर करने के लिए आवश्यक है, जो नीचे दिए गए पाठ से स्पष्ट होगा।



2.3। रचना

रचना में, एक वस्तु को अन्य वस्तुओं को शामिल करके निर्धारित किया जाता है, जो कि विरासत के बजाय, इसमें बस उन्हें समाहित किया जाता है। इस प्रकार के संबंधों को है-ए कहा जाता है और इसमें शामिल वस्तुएं सदस्यता नियमों के अधीन होती हैं।

3. क्या गो में विरासत है?

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

4. "सरल विरासत को बाहर फेंकना बेहतर है"

इसके बाद, मैं एक JavaWorld लेख से एक टुकड़ा दूंगा - "क्यों बुराई फैलती है" :

डिजाइन पैटर्न पर चार गिरोहों की पुस्तक विस्तार (कार्यान्वयन) के माध्यम से विरासत के साथ कार्यान्वयन (फैली हुई) के माध्यम से विरासत के प्रतिस्थापन पर विस्तार से चर्चा करती है।



मैंने एक बार एक जावा समूह उपयोगकर्ता की एक सभा का दौरा किया, जहाँ जेम्स गोसलिंग (जावा के निर्माता) को एक बात करने के लिए आमंत्रित किया गया था। एक यादगार क्यू एंड ए सत्र के दौरान, किसी ने उनसे पूछा: "यदि आप जावा नए सिरे से कर सकते हैं, तो आप क्या बदलेंगे?" "मैं कक्षाएं फेंक दूंगा," उन्होंने जवाब दिया। श्रोताओं में हंसी के मर जाने के बाद, उन्होंने समझाया कि वास्तविक समस्या मूल रूप से कक्षाओं के साथ नहीं थी, लेकिन कार्यान्वयन के माध्यम से विरासत के साथ (संबंध का विस्तार)। इंटरफेस (लागू संबंध) के माध्यम से विरासत को प्राथमिकता दी जाती है, जहां संभव हो कार्यान्वयन के माध्यम से विरासत को टाला जाना चाहिए।

5. गो में वस्तु संबंध

5.1। प्रकार रचना

नियमित विरासत के बजाय, गो सख्ती से विरासत के बजाय संरचना के सिद्धांत का उपयोग करता है , और संरचनाओं और इंटरफेस के बीच संबंध is-a और has-a के सिद्धांतों पर बनाए जाते हैं। यहां उपयोग की जाने वाली ऑब्जेक्ट रचना तंत्र इनलाइन प्रकार के प्रतीत होते हैं, इसलिए गो आपको एक संरचना में एक संरचना को एम्बेड करने की अनुमति देता है, जबकि एक संबंध बनाता है। एक अच्छा उदाहरण नीचे दिए गए कोड में व्यक्ति और पता प्रकार के बीच का संबंध है:

 type Person struct { Name string Address Address } type Address struct { Number string Street string City string State string Zip string } func (p *Person) Talk() { fmt.Println("Hi, my name is", p.Name) } func (p *Person) Location() { fmt.Println("Im at", p.Address.Number, p.Address.Street, p.Address.City, p.Address.State, p.Address.Zip) } func main() { p := Person{Name: "Steve"} p.Address = Address{ Number: "13", Street: "Main" } p.Address.City = "Gotham" p.Address.State = "NY" p.Address.Zip = "01313" p.Talk() p.Location() }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

परिणाम:

 > Hi, my name is Steve > Im at 13 Main Gotham NY 01313
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

play.golang.org/p/5TVBDR7AYo



इस उदाहरण में, यह महत्वपूर्ण है कि Person



अंदर पता एक अलग इकाई बना रहे। main



कार्य यह दर्शाता है कि p.Address



को एड्रेस ऑब्जेक्ट कैसे असाइन किया p.Address



और, एक डॉट के माध्यम से अपने फ़ील्ड्स को इनिशियलाइज़ करके, इनिशियलाइज़ करें।



5.2। उप-प्रकार बहुरूपता का अनुकरण



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



एक-एक संबंध बनाना उसी तरह से काम करता है। व्यक्ति ( Person



) को बोलने का तरीका बताएं। Citizen



एक व्यक्ति ( Person



) है, और इसलिए यह भी जानता है कि कैसे बात करें ( Talk



)। हम इसे ध्यान में रखते हुए पिछले उदाहरण का विस्तार करते हैं।

 type Citizen struct { Country string Person //     } func (c *Citizen) Nationality() { fmt.Println(c.Name, "is a citizen of", c.Country) } func main() { c := Citizen{} c.Name = "Steve" c.Country = "America" c.Talk() c.Nationality() }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

परिणाम:

 > Hi, my name is Steve > Steve is a citizen of America
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

play.golang.org/p/eCEpLkQPR3



हम इस मामले में Citizen



संरचना क्षेत्र (केवल जिस प्रकार का संकेत दिया गया है) का उपयोग करते हुए एक अनाम संरचना क्षेत्र का उपयोग करते हुए एक संबंध स्थापित करते हैं। Citizen



प्रकार ने व्यक्तिगत प्रकार के सभी गुणों और विधियों का अधिग्रहण किया है और इनमें से कुछ गुणों और विधियों को अपने साथ पूरक या ओवरलैप करने की क्षमता है। उदाहरण के लिए, शहर के निवासियों को थोड़ा अलग तरीके से प्रतिक्रिया दें:

 func (c *Citizen) Talk() { fmt.Println("Hello, my name is", c.Name, "and Im from", c.Country) }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

परिणाम:

 > Hello, my name is Steve and Im from America > Steve is a citizen of America
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

play.golang.org/p/jafbVPv5H9



ध्यान दें कि अब main



विधि *Person.Talk()



बजाय *Person.Talk()



कॉल करती है।

6. अनाम क्षेत्र क्यों बहुरूपता नहीं देते हैं

इसके दो कारण हैं।



6.1। प्रत्येक निर्मित प्रकारों के व्यक्तिगत क्षेत्रों तक पहुँच प्राप्त करता है

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

 func main() { c := Citizen{} c.Name = "Steve" c.Country = "America" c.Talk() // <-   c.Person.Talk() // <-   c.Nationality() }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

परिणाम:

 > Hello, my name is Steve and Im from America > Hi, my name is Steve > Steve is a citizen of America
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

6.2। एक वंश प्रकार पूर्वज प्रकार नहीं बन जाता है

यदि बहुरूपता वास्तविक था, तो एक अनाम क्षेत्र समावेशी प्रकार को सम्मिलित प्रकार का कारण बनेगा, लेकिन गो में, शामिल और समावेशी दोनों अलग-अलग रहेंगे। एक बार देखने के लिए बेहतर है, एक उदाहरण दें:

 type A struct { } type B struct { A // B is-a A } func save(A) { // xxx } func main() { b := &B{} save(b) // OOOPS! b IS NOT A }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

परिणाम:

 > prog.go:17: cannot use b (type *B) as type A in function argument > [process exited with non-zero status]
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

play.golang.org/p/EmodogIiQU



इस उदाहरण का सुझाव हैकर न्यूज़ की इस टिप्पणी में दिया गया है। धन्यवाद, ऑप्टिमाइज़र।

7. वास्तविक उपप्रकार बहुरूपता

गो में इंटरफेस प्रकृति में बहुत ही अनोखे हैं। इस खंड में, हम बहुरूपता को लागू करने के लिए इंटरफेस के उपयोग पर ध्यान केंद्रित करेंगे, जो कि उनकी प्राथमिक चिंता नहीं है।



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



तथ्य यह है कि प्रकार इंटरफ़ेस से मेल खाती है, इंटरफ़ेस द्वारा आवश्यक विधियों के सेट और प्रकार की जाँच के लिए उपलब्ध तरीकों के सेट की तुलना करके स्वचालित रूप से जांच की जाती है। दूसरे शब्दों में, इस तरह के रवैये को "यदि कुछ कर सकता है, तो इसे यहाँ इस्तेमाल किया जा सकता है" के रूप में वर्णित किया जा सकता है, अर्थात्, बतख टाइपिंग का सिद्धांत है।



पिछले उदाहरण पर लौटते हुए, हम एक नया SpeakTo



फ़ंक्शन SpeakTo



और main



हम इसे Citizen



और Person



उदाहरणों में लागू करने का प्रयास करेंगे।

 func SpeakTo(p *Person) { p.Talk() } func main() { p := &Person{Name: "Dave"} c := &Citizen{Person: Person{Name: "Steve"}, Country: "America"} SpeakTo(p) SpeakTo(c) }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

परिणाम:

 > Running it will result in > prog.go:48: cannot use c (type *Citizen) as type *Person in function argument > [process exited with non-zero status]
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

play.golang.org/p/fkKz0FkaEk



जैसा कि अपेक्षित था, डिज़ाइन बस गलत है। इस मामले में, Citizen



एक Person



नहीं हैं, भले ही उनके पास सामान्य गुण हैं। हालाँकि, हम Human



इंटरफ़ेस जोड़ देंगे, इसे SpeakTo



फ़ंक्शन का स्वीकृत प्रकार SpeakTo



हैं SpeakTo



और अब, सब कुछ योजना के अनुसार हुआ।

 type Human interface { Talk() } func SpeakTo(h Human) { h.Talk() } func main() { p := &Person{Name: "Dave"} c := &Citizen{Person: Person{Name: "Steve"}, Country: "America"} SpeakTo(p) SpeakTo(c) }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

परिणाम:

 > Hi, my name is Dave > Hi, my name is Steve
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

play.golang.org/p/vs92w57c5-



संक्षेप में, हम गो में बहुरूपता के बारे में दो महत्वपूर्ण बिंदु बना सकते हैं:

• अनाम फ़ील्ड्स का उपयोग करते हुए, इंटरफ़ेस के प्रकार मिलान को प्राप्त करना संभव है, जिसमें इंटरफेस के सेट को एक साथ मिलान करना शामिल है, जिससे लगभग विहित बहुरूपता प्राप्त होती है।
• मूल्य ( c.Name = "Xlab"
  
  
  
  ) का उपयोग करते समय गो, उप-प्रकार बहुरूपता प्रदान कर सकता है, लेकिन वास्तव में सभी प्रकार अलग-अलग होते हैं। जैसा कि पिछले उदाहरण में दिखाया गया है, Citizen
  
  
  
  पर Name
  
  
  
  संपत्ति सेट करने के लिए, हमें व्यक्तिगत रूप से इस संपत्ति को व्यक्तिगत रूप से निर्दिष्ट करना होगा, फिर व्यक्तिगत ऑब्जेक्ट को Citizen
  
  
  
  पर संबंधित फ़ील्ड पर असाइन करना होगा। ( Citizen{Person: Person{Name: "Steve"}, Country: "America"}
  
  
  
  समग्र शाब्दिक Citizen{Person: Person{Name: "Steve"}, Country: "America"}
  
  
  
  पर भाषण)।

8. सारांश

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



तो, ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग के नए मॉडल को पूरा करें - वस्तुओं के बिना!



~ अनुवाद और Xlab द्वारा अनुकूलन।

इसे भी देखें: "कोड का पुन : उपयोग एक उदाहरण के साथ करें"

वैसे, बस इस मामले में, मैं इस उद्धरण को यहां उद्धृत करूंगा:

मैंने ऑब्जेक्ट ओरिएंटेड शब्द का आविष्कार किया है और मैं आपको बता सकता हूं कि मेरे पास सी ++ नहीं था।

- एलन के