परिभाषा

एनकैप्सुलेशन डेटा या उन तरीकों तक पहुँच को नियंत्रित करने के लिए उपकरणों का एक सेट है जो उस डेटा का प्रबंधन करते हैं। "एन्कैप्सुलेशन" शब्द की एक विस्तृत परिभाषा मेरे पिछले प्रकाशन में इस लिंक पर Habré में पाई जा सकती है। यह लेख C ++ और C में एनकैप्सुलेशन उदाहरणों पर केंद्रित है।

C ++ में एनकैप्सुलेशन

डिफ़ॉल्ट रूप से, एक वर्ग ( class ) में डेटा और विधियाँ निजी ( private ) हैं; उन्हें केवल उसी वर्ग द्वारा पढ़ा और संशोधित किया जा सकता है जिससे वे संबंधित हैं। C ++ द्वारा प्रदान किए गए उपयुक्त कीवर्ड का उपयोग करके एक्सेस स्तर को बदला जा सकता है।

कई क्वालिफायर C ++ में उपलब्ध हैं, और वे डेटा एक्सेस को निम्नानुसार संशोधित करते हैं:

• सार्वजनिक डेटा सभी के लिए उपलब्ध है;
• संरक्षित ( protected ) - केवल कक्षा और बाल वर्गों के लिए उपलब्ध;
• निजी - private - केवल उसी वर्ग के लिए उपलब्ध है जिससे वे संबंधित हैं।

संक्षिप्तता के लिए, केवल दो स्तरों (निजी और सार्वजनिक) को उदाहरणों में हाइलाइट किया जाएगा।

एनकैप्सुलेशन उदाहरण

Contact वर्ग में, सार्वजनिक चर और तरीके मुख्य कार्यक्रम से सुलभ हैं। निजी चर और तरीके केवल कक्षा द्वारा ही पढ़े, कहे या बदले जा सकते हैं।

 #include <iostream> using namespace std; class Contact { private: int mobile_number; // private variable int home_number; // private variable public: Contact() // constructor { mobile_number = 12345678; home_number = 87654321; } void print_numbers() { cout << "Mobile number: " << mobile_number; cout << ", home number: " << home_number << endl; } }; int main() { Contact Tony; Tony.print_numbers(); // cout << Tony.mobile_number << endl; // will cause compile time error return 0; } 

मुख्य कार्यक्रम ( main ) से निजी चर mobile_number को प्रिंट या संशोधित करने का प्रयास एक संकलन त्रुटि का कारण होगा क्योंकि कक्षा में निजी डेटा तक पहुंच सीमित है।

दोस्तों के साथ एनकैप्सुलेशन उल्लंघन (अच्छा अभ्यास)

C ++ में, कीवर्ड "दोस्त" है जो आपको डेटा तक पहुंचने के लिए सामान्य नियमों में अपवाद जोड़ने की अनुमति देता है। यदि किसी फ़ंक्शन या वर्ग को Contact वर्ग का मित्र कहा जाता है, तो उन्हें संरक्षित या निजी डेटा तक मुफ्त पहुंच मिलती है।

दोस्ती के दो बुनियादी नियम हैं - दोस्ती विरासत में नहीं मिलती और न ही आपसी होती है। इसके अलावा, "मित्रों" की उपस्थिति डेटा सुरक्षा के स्तर को नहीं बदलती है - "मित्र" के अपवाद के साथ निजी डेटा निजी रहता है।

 #include <iostream> using namespace std; class Contact { private: int mobile_number; // private variable int home_number; // private variable public: Contact() // constructor { mobile_number = 12345678; home_number = 87654321; } // Declaring a global 'friend' function friend void print_numbers( Contact some_contact ); }; void print_numbers( Contact some_contact ) { cout << "Mobile number: " << some_contact.mobile_number; cout << ", home number: " << some_contact.home_number << endl; } int main() { Contact Tony; print_numbers(Tony); return 0; } 

इस उदाहरण में, print_numbers() फ़ंक्शन एक सामान्य फ़ंक्शन है, Contact वर्ग की एक विधि नहीं है। print_numbers() फ़ंक्शन print_numbers() Contact वर्ग के "मित्र" के print_numbers() घोषित करना एकमात्र कारण है जो print_numbers() फ़ंक्शन का निजी डेटा तक पहुंच है। यदि आप किसी मित्र की परिभाषा के साथ लाइन को हटाते हैं, तो कोड संकलन नहीं करेगा।

नोट : दोस्तों को गाली देना सबसे अच्छा नहीं है। मित्र को जोड़ना एक अपवाद के रूप में माना जाना चाहिए, न कि सामान्य अभ्यास के रूप में।

प्रकार रूपांतरण और पॉइंटर्स (खराब प्रैक्टिस) के साथ एनकैप्सुलेशन उल्लंघन

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

C ++ को C से कई उपकरण विरासत में मिले हैं, जिनमें से एक typecasting । डिफ़ॉल्ट रूप से, कक्षा में सभी चर और विधियां निजी हैं। इसी समय, संरचना ( struct ) में डेटा एक्सेस का मानक स्तर सार्वजनिक है। एक संरचना या एक पूरी तरह से सार्वजनिक वर्ग बनाना संभव है जिसमें डेटा Contact वर्ग में डेटा के लिए व्यक्तिगत रूप से स्थित होगा और निजी डेटा तक पहुंचने के लिए टाइप रूपांतरण का उपयोग करेगा।

 #include <iostream> using namespace std; class Contact { private: int mobile_number; // private variable int home_number; // private variable public: Contact() // constructor { mobile_number = 12345678; home_number = 87654321; } void print_numbers() { cout << "Mobile number: " << mobile_number; cout << ", home number: " << home_number << endl; } }; struct Contact_struct { int mobile_number; int home_number; }; int main() { Contact Tony; Contact_struct * structured_Tony; Tony.print_numbers(); structured_Tony = (Contact_struct *) & Tony; structured_Tony->mobile_number = 20; structured_Tony->home_number = 30; Tony.print_numbers(); return 0; } 

निजी डेटा टाइप रूपांतरण के कारण पढ़ा और संशोधित किया गया है

C एनकैप्सुलेशन

एनकैप्सुलेशन को पारंपरिक रूप से प्रमुख ओओपी सिद्धांतों में से एक माना जाता है। हालाँकि, यह प्रक्रियात्मक रूप से उन्मुख भाषाओं में इस सिद्धांत के उपयोग को सीमित नहीं करता है। सी में, "निजी" और "सार्वजनिक" कीवर्ड की कमी के बावजूद, लंबे समय तक एनकैप्सुलेशन का उपयोग किया गया है।

निजी चर

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

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

 #include "private_var.h" #include <stdio.h> #include <stdlib.h> struct Contact { int mobile_number; int home_number; }; struct Contact * create_contact() { struct Contact * some_contact; some_contact = malloc(sizeof(struct Contact)); some_contact->mobile_number = 12345678; some_contact->home_number = 87654321; return( some_contact ); } void delete_contact( struct Contact * some_contact ) { free(some_contact); } 

संबंधित हेडर फ़ाइल "Private_var.h" में, Contact संरचना घोषित की गई थी, लेकिन इसकी सामग्री मुख्य कार्यक्रम के लिए छिपी रही।

 #ifndef PRIVATE_VAR #define PRIVATE_VAR struct Contact; struct Contact * create_contact(); void delete_contact( struct Contact * some_contact ); #endif /* PRIVATE_VAR */ 

इस प्रकार, "main.c" के लिए संरचना की सामग्री अज्ञात है और निजी डेटा को पढ़ने या संशोधित करने का प्रयास एक संकलन त्रुटि का कारण होगा।

 #include "private_var.h" #include <stdio.h> int main() { struct Contact * Tony; Tony = create_contact(); // printf( "Mobile number: %d\n", Tony->mobile_number); // will cause compile time error delete_contact( Tony ); return 0; } 

पॉइंटर्स के साथ निजी चर एक्सेस करना

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

संरचना में चर तक पहुंच सीमित है। हालांकि, केवल चर छिपे हुए हैं, स्मृति नहीं जिसमें डेटा संग्रहीत है। पॉइंटर्स को मेमोरी एड्रेस के संदर्भ के रूप में माना जा सकता है, और यदि यह मेमोरी प्रोग्राम के लिए उपलब्ध है, तो इस मेमोरी में संग्रहीत डेटा को पढ़ा और बदला जा सकता है। यदि सूचक को उस मेमोरी को सौंपा गया है जिसमें संरचना अपना डेटा संग्रहीत करती है - उन्हें पढ़ा जा सकता है। समान संरचना परिभाषा (समान ".c" और ".h" फ़ाइलें) और संशोधित "main.c" फ़ाइल का उपयोग करके, एक्सेस प्रतिबंध पर काबू पा लिया गया था।

 #include "private_var.h" #include <stdio.h> int main() { struct Contact * Tony; Tony = create_contact(); int * mobile_number_is_here = (int *)Tony; printf("Mobile number: %d\n", *mobile_number_is_here); int * home_number_is_here = mobile_number_is_here + 1; *home_number_is_here = 1; printf("Modified home number: %d\n", *home_number_is_here); delete_contact( Tony ); return 0; } 

संरचना में डेटा को पढ़ा और संशोधित किया गया है

निजी कार्य

कार्य, डिफ़ॉल्ट रूप से बाहरी (बाहरी) होने के कारण, पूरे तथाकथित translation unit में दिखाई देते हैं। दूसरे शब्दों में, यदि कई फ़ाइलों को एक ऑब्जेक्ट फ़ाइल में एक साथ संकलित किया जाता है, तो इनमें से कोई भी फ़ाइल किसी भी फ़ाइल से किसी भी फ़ंक्शन तक पहुंचने में सक्षम होगी। फ़ंक्शन बनाते समय "स्थिर" static का उपयोग करना इसकी दृश्यता को उस फ़ाइल तक सीमित कर देगा जिसमें इसे परिभाषित किया गया था। इसलिए, फ़ंक्शन की गोपनीयता सुनिश्चित करने के लिए, आपको कई चरणों को करने की आवश्यकता है:

• फ़ंक्शन को स्थिर ( static ) स्रोत फ़ाइल (.c) में या संबंधित हेडर फ़ाइल (.h) में घोषित किया जाना चाहिए;
• फ़ंक्शन की परिभाषा एक अलग स्रोत फ़ाइल में होनी चाहिए।

इस उदाहरण में, "Private_funct.c" फ़ाइल में स्थिर फ़ंक्शन print_numbers() को परिभाषित किया गया था। वैसे, delete_contact() फ़ंक्शन सफलतापूर्वक print_numbers() कॉल print_numbers() क्योंकि वे एक ही फ़ाइल में हैं।

 #include "private_funct.h" #include <stdio.h> #include <stdlib.h> struct Contact { int mobile_number; int home_number; }; struct Contact * create_contact() { struct Contact * some_contact; some_contact = malloc(sizeof(struct Contact)); some_contact->mobile_number = 12345678; some_contact->home_number = 87654321; return( some_contact ); } static void print_numbers( struct Contact * some_contact ) { printf("Mobile number: %d, ", some_contact->mobile_number); printf("home number = %d\n", some_contact->home_number); } void delete_contact( struct Contact * some_contact ) { print_numbers(some_contact); free(some_contact); } 

संबंधित हेडर फ़ाइल "Private_funct.h" में, print_numbers() एक स्थिर फ़ंक्शन के रूप में घोषित print_numbers() गया है।

 #ifndef PRIVATE_FUNCT_H #define PRIVATE_FUNCT_H struct Contact; struct Contact * create_contact(); static void print_numbers( struct Contact * some_contact ); void delete_contact( struct Contact * my_points ); #endif /* PRIVATE_FUNCT_H */ 

मुख्य कार्यक्रम, "main.c", सफलतापूर्वक print_numbers() कॉल print_numbers() अप्रत्यक्ष रूप से delete_contact() माध्यम से, क्योंकि दोनों फ़ंक्शन एक ही दस्तावेज़ में हैं। हालाँकि, मुख्य प्रोग्राम से print_numbers() को कॉल करने का प्रयास print_numbers() त्रुटि print_numbers() देगा।

 #include "private_funct.h" #include <stdio.h> int main() { struct Contact * Tony; Tony = create_contact(); // print_numbers( Tony ); // will cause compile time error delete_contact( Tony ); return 0; } 

निजी सुविधाओं तक पहुँचना

मुख्य कार्यक्रम से print_numbers() कॉल print_numbers() । ऐसा करने के लिए, आप goto कीवर्ड का उपयोग कर सकते हैं या main में एक निजी फ़ंक्शन के लिए एक पॉइंटर पास कर सकते हैं। दोनों तरीकों को स्रोत फ़ाइल "Private_funct.c" में या सीधे फ़ंक्शन के शरीर में परिवर्तन की आवश्यकता होती है। चूंकि ये विधियां एनकैप्सुलेशन को बायपास नहीं करती हैं और इसे रद्द करती हैं, वे इस लेख के दायरे से परे हैं।

निष्कर्ष

ओओपी भाषाओं के बाहर एनकैप्सुलेशन मौजूद है। आधुनिक ओओपी भाषाएं एनकैप्सुलेशन का उपयोग सुविधाजनक और प्राकृतिक बनाती हैं। इनकैप्सुलेशन को दरकिनार करने के कई तरीके हैं और संदिग्ध प्रथाओं से बचने के लिए सी और सी ++ दोनों में इसे संरक्षित करने में मदद मिलेगी।