वस्तु उन्मुख सी

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

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

class compressor { public: virtual void compress(void* data)=0; virtual void uncompress(void* data)=0; virtual void status()const=0; }; class rar_compressor : public compressor {...}; class zip_compressor : public compressor {...}; void do_compress(compressor* c, void* in_data, void* out_data) { c->compress(in_data); c->uncompress(out_data); c->status(); } 

या तो:

 template<typename Cmp> void do_compress(Cmp& c, void* in_data, void* out_data) { c.compress(in_data); c.uncompress(out_data); c.status(); } 

आइए इस योजना को सी में लागू करने का प्रयास करें।

 #compressor_interface.h typedef struct compressor_t { // `public` interface void (*compress)(struct compressor_t*, void* data); void (*uncompress)(struct compressor_t*, void* data); void (*status)(struct compressor_t*); // `private` part void* impl_; } compressor_t; 

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

 #rar.h void rar_init(compressor_t* c, int cr); void rar_free(compressor_t* c); 

 #rar.c typedef struct { int compressed_ratio; int error; int time_to_finish; } rar_impl_t; //////////////////////////////////////////////////////////////////////////////// //      #define PREPARE_IMPL(c) \ assert(c); \ assert(c->impl_); \ rar_impl_t* impl = (rar_impl_t*)c->impl_; //////////////////////////////////////////////////////////////////////////////// static void compress(compressor_t* c, void* data) { PREPARE_IMPL(c) printf("RAR: compressor working. Compressed ratio: %d\n", impl->compressed_ratio); } //////////////////////////////////////////////////////////////////////////////// static void uncompress(compressor_t* c, void* data) { PREPARE_IMPL(c) printf("RAR: uncompressor working. Will be finished in %d.\n", impl->time_to_finish); } //////////////////////////////////////////////////////////////////////////////// static void status(compressor_t* c) { PREPARE_IMPL(c) printf("Compressed ratio: %d, error: %d\n", impl->compressed_ratio, impl->error); } //////////////////////////////////////////////////////////////////////////////// //  void rar_init(compressor_t* c, int cr) { assert(c); c->impl_ = malloc(sizeof(rar_impl_t)); rar_impl_t* impl = (rar_impl_t*)c->impl_; //  `private`  impl->time_to_finish = 5; impl->compressed_ratio = cr; impl->error = 0; //  `public`  c->compress = &compress; c->uncompress = &uncompress; c->status = &status; } //////////////////////////////////////////////////////////////////////////////// // void rar_free(compressor_t* c) { PREPARE_IMPL(c) free(impl); } 

"क्लास" ज़िप उसी तरह से डिज़ाइन किया गया है, इसलिए मैं यहां इसके कोड का हवाला नहीं दूंगा। केवल एक चीज जिस पर मैं जोर देना चाहूंगा, वह है इन वर्गों का "कंस्ट्रक्टर्स", सदस्य कार्यों के विपरीत, उनके पास एक ही हस्ताक्षर नहीं है, इसके अलावा, प्रत्येक "वर्ग" के लिए कई हो सकते हैं।

और अब उपयोग कोड:

 void work(compressor_t* c, void* data_to_compress, void* data_to_decompress) { c->compress(c, data_to_compress); c->uncompress(c, data_to_decompress); c->status(c); } int main() { void* uncompressed_data[DATA_SIZE]; void* compressed_data[DATA_SIZE]; compressor_t rar; rar_init(&rar, COMP_RATIO); work(&rar, uncompressed_data, compressed_data); rar_free(&rar); printf("\n"); compressor_t zip; zip_init(&zip, VOLUMES); work(&zip, uncompressed_data, compressed_data); zip_free(&zip); return 0; } 

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

तो अच्छा है, हमने OOP के तीन में से दो घटकों का पता लगाया (क्या आप निश्चित रूप से उन्हें दिल से याद करते हैं?) बची हुई आखिरी चीज विरासत है। सिद्धांत रूप में, विरासत को कई अलग-अलग तरीकों से लागू किया जा सकता है, मैं यहां वर्णन करूंगा कि जो मुझे सबसे सुरुचिपूर्ण लगता है।

कार्यान्वयन सी सुविधा पर निर्भर करता है, जो आपको अन्य संरचनाओं के सदस्यों के रूप में अनाम संरचना के सदस्यों का उपयोग करने की अनुमति देता है (जीसीसी में, आपको ध्वज "-std = c11" या "-fms- एक्सटेंशन") सेट करने की आवश्यकता हो सकती है। जिप कंप्रेशर से एक "वर्ग", "विरासत" लिखते हैं

 typedef struct logging_compressor_t { union { struct compressor_t; struct compressor_t base; }; void (*log)(struct logging_compressor_t* lc); void *impl_; //   } logging_compressor_t; 

अब हम "बेस" "क्लास" को सीधे एक्सेस कर सकते हैं

 logging_compressor_t lc; lc.compress(...) 

तो डेटा सदस्य के माध्यम से

 lc.base.compress(...) 

इस "वर्ग" का उपयोग मौजूदा कोड में बहुरूपी है जो निम्नानुसार है

 work(&lc.base, uncompressed_data, compressed_data); 

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