C ++ टाइप कक्षाएं

यह पहले ही वर्णित किया गया है कि सी ++ में मठों को बिना किसी प्रकार की कक्षाओं के कैसे लागू किया जाए । मैं यह दिखाना चाहता हूं कि एक उदाहरण के रूप में मठों का उपयोग करके किस प्रकार की कक्षाएं लागू की जा सकती हैं।
इस तकनीक का व्यापक रूप से स्काला में उपयोग किया जाता है, लेकिन इसका उपयोग C ++ में भी किया जा सकता है। मैंने इसे संक्षिप्त रूप से पुस्तकालयों के एकीकृत वर्णन की कठिनाइयों के उदाहरण के रूप में वर्णित किया है, अब मैं इसके कार्यान्वयन का प्रदर्शन करूंगा।
यह ध्यान दिया जाना चाहिए कि प्रकार की कक्षाएं न केवल हास्केल और मर्करी जैसी घोषणात्मक भाषाओं में उपयोग की जाती हैं, लेकिन वे काफी क्लासिक गो और जंग में परिलक्षित होती हैं।
यह तकनीक कॉमन लिस्प और क्लोजर से मल्टीमिथोड को लागू करने के लिए भी उपयुक्त है।

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


प्रकार वर्गों का मूल विचार इंटरफ़ेस कार्यान्वयन को डेटा संरचना से अलग करना है। एक ही इंटरफ़ेस का उपयोग पूरी तरह से अलग डेटा संरचनाओं के साथ काम करने के लिए किया जा सकता है, और प्रत्येक डेटा प्रकार के लिए अलग से लागू किया जाना चाहिए। इस इंटरफ़ेस का उपयोग करने वाले कोड को इसके कार्यान्वयन के विवरण को जानने की आवश्यकता नहीं है।
जटिलता के मोनैड्स के साथ, यह जोड़ता है कि यह इंटरफ़ेस एक अन्य प्रकार द्वारा सामान्यीकृत जेनेरिक प्रकार के लिए लागू किया गया है।

इंटरफ़ेस का कार्यान्वयन कहीं संग्रहीत किया जाना चाहिए, लेकिन इसके लिए हमारे पास केवल कक्षाएं हैं:

#include <stddef.h> template <template<typename _> class M> class monadVTBL { public: template<typename v, typename x> static M<v> bind(M<x>, M<v>(*)(x)); template<typename v> static M<v> mreturn(v); }; template<template<typename _> class M, typename v, typename x> M<v> bind(M<x> i, M<v>(*f)(x), monadVTBL<M> *tbl = NULL) { return monadVTBL<M>::bind(i, f); } template<template<typename _> class M, typename v> M<v> mreturn(vi, monadVTBL<M> *tbl = NULL) { return monadVTBL<M>::mreturn(i); } 

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

 template <template<typename _> class M> M<char> inc(char c) { return mreturn<M,char>(c+1); } 

एक साधु का उपयोग करते हुए एक काफी सरल कार्य।
हास्केल में, वह बाहर दिखेगी

 inc :: (Monad m) => Char -> m Char inc c = return (succ c) 

यहां लौटने का मतलब है कि C ++ की तुलना में कुछ अलग है।

अब आइओ मोनाड के कार्यान्वयन के लिए आगे बढ़ते हैं। इस मामले में जिन वस्तुओं के साथ मोनाड इंटरफ़ेस काम करता है वे हैं I / O संचालन। हास्केल में, ये सामान्य मूल्य हैं, सी ++ में उन्हें कक्षाओं द्वारा मॉडल किया जाएगा।

 #include<stdio.h> template<typename v> class IOop { public: virtual v run() = 0; }; template<typename v> class IOm { public: IOop<v> *op; IOm(IOop<v> *o) { op = o; } v run() { op->run(); } }; 

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

 class getChar: public IOop<char> { public: getChar() {} virtual char run() { return getchar(); } } _getChar[1]; IOm<char> getChar(_getChar); typedef class unit { } unit; unit Unit; class _putChar: public IOop<unit> { char v; public: _putChar(char c) { v = c; } virtual unit run() { putchar(v); return Unit; } }; class IOm<unit> putChar(char c) { IOm<unit> o(new _putChar(c)); return o; }; 

लेकिन दो विशिष्ट I / O संचालन मानक इनपुट से एक चरित्र प्राप्त करने और मानक आउटपुट के लिए चरित्र को आउटपुट करने के लिए हैं। और एक फ़ंक्शन भी है जो एक चरित्र को एक ऑपरेशन में बदल देता है जो इसे आउटपुट करता है।

 template<typename v> class mconst: public IOop<v> { vr; public: mconst(vx) { r=x; } virtual v run() { return r; } }; 

यह वर्ग मोनैडिक ऑपरेशन "रिटर्न" को लागू करता है, जो इस मामले में एक इनपुट-आउटपुट ऑपरेशन बनाता है जो हमेशा एक "परिचय" देता है।

 template<typename v, typename i> class mbind: public IOop<v> { IOop<i> *s; IOm<v> (*f)(i); public: v run() { return (*f)(s->run()).run(); } mbind(IOop<i> *x, IOm<v> (*g)(i)) { s=x; f=g; } }; 

और यह ऑपरेशन ">> =", जो नए मोनाद के जनरेटर के साथ मठ को जोड़ता है।

 template<> class monadVTBL<IOm> { public: template<typename v, typename i> static IOm<v> bind(IOm<i> x, IOm<v>(*f)(i)) { IOm<v> b(new mbind<v,i>(x.op,f)); return b; } template<typename v> static IOm<v> mreturn(vx) { IOm<v> r(new mconst<v>(x)); return r; } }; 

और यहां सबसे महत्वपूर्ण बात आईओ के लिए मठ के कार्यान्वयन की विशेषज्ञता है।

 template<typename i> IOm<unit> ignNL(iv) { return bind<IOm,unit,char>(mreturn<IOm,char>('\n'),putChar); } 

यह एक IO जनरेटर है जो पिछले मोनड के परिणाम को अनदेखा करता है और '\ n' प्रिंट करता है।

 ign :: a -> IO () ign _ = putChar '\n' 

IO (और कुछ अन्य मोनडर्स, जैसे पर्सर्स) के लिए, पिछले मोनड को अनदेखा करना एक काफी लोकप्रिय ऑपरेशन है और इसके लिए एक फ़ंक्शन है:

 (>>) :: (Monad m) => ma -> mb -> mb a >> b = a >>= \_ -> b 

अब देखते हैं कि यह कैसे काम करता है:

 bind<IOm,unit,unit>(bind<IOm,unit,char>(bind<IOm,char,char>(getChar,inc),putChar),ignNL<unit>).run(); 

हम मानक इनपुट से एक चरित्र पढ़ते हैं, इसे बढ़ाते हैं, इसे प्रिंट करते हैं, और लाइन फ़ीड को प्रिंट करते हैं।

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

 #include<vector> template<typename v> class myvector: public std::vector<v> { }; 

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

 template<> class monadVTBL<myvector> { public: template<typename v, typename i> static myvector<v> bind(myvector<i> x, myvector<v>(*f)(i)){ myvector<v> e; for(typename myvector<i>::iterator it = x.begin(); it != x.end(); ++it) { myvector<v> c = f(*it); for(typename myvector<v>::iterator i = c.begin(); i != c.end(); ++i) { e.push_back(*i); } } return e; } template<typename v> static myvector<v> mreturn(vx) { myvector<v> e; e.push_back(x); return e; } }; 

एसटीडी की कार्यक्षमता :: वेक्टर मोनाड हास्केल में लिस्ट मोनाड की कार्यक्षमता के समान है।

हम कोशिश करते हैं कि यह कैसे काम करता है:

  myvector<char> x; x.push_back('q'); x.push_back('w'); x.push_back('e'); myvector<char> z = bind<myvector,char,char>(x,inc); for(typename myvector<char>::iterator i = z.begin(); i != z.end(); ++i) { std::cout << *i; } 

ऐसी कार्यक्षमता के लिए, फ़नकार के प्रकारों का एक वर्ग पर्याप्त होगा, लेकिन मैं अधिक जटिल उदाहरण के साथ नहीं आना चाहता था।