मुहावरे पिम्पल और फास्ट पिंपल - कार्यान्वयन के लिए सूचक

अन्य नाम: पुल, संकलन फ़ायरवॉल, हैंडल / बॉडी

मान लीजिए कि हमें सॉकेट्स का उपयोग करके क्रॉस-प्लेटफ़ॉर्म नेटवर्क एप्लिकेशन लिखने की आवश्यकता है। इसके लिए, हमें GeneralSocket class ("Visible class") की आवश्यकता है, जो एक विशिष्ट प्लेटफ़ॉर्म ("हिडन क्लास") के क्रियान्वयन के विवरण को संलग्न करेगा। अक्सर उपयोगकर्ताओं या अन्य डेवलपर्स से कार्यान्वयन विवरण छिपाने की आवश्यकता होती है:

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

एक उदाहरण पर विचार करें:

//GeneralSocket.h

#include “UnixSocketImpl.h”



Class GeneralSocket{

public :

connect();

private :

UnixSocketImpl socket;

}



//GeneralSocket.cxx

GeneralSocket::connect(){

socket.connectImpl();

}



* This source code was highlighted with Source Code Highlighter .

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

//GeneralSocket.h

Class UnixSocketImpl;



Class GeneralSocket

{

public :

GeneralSocket();

void connect();

private :

UnixSocketImpl * socket;

}



//GeneralSocket.cxx

#include “UnixSocketImpl.h”



GeneralSocket::GeneralSocket() : socket ( new UnixSocketImpl){}



GeneralSocket::~GeneralSocket() {

delete socket;

socket = 0;

}



void GeneralSocket::connect() {

socket->connectImpl();

}



* This source code was highlighted with Source Code Highlighter .

हम हेडर फ़ाइल में UnixSocketImpl.h से छुटकारा पाने में कामयाब रहे और इसे जनरल सॉकेट क्लास की कार्यान्वयन फ़ाइल में स्थानांतरित कर दिया। अब उपयोगकर्ता एक विशिष्ट कार्यान्वयन के लिए सक्षम नहीं होगा, और केवल सामान्य सॉकेट क्लास के इंटरफ़ेस के माध्यम से कार्यक्षमता का उपयोग करेगा।



C ++ में, कक्षा में बदलाव (निजी सदस्य कार्यों में भी) के मामले में, इस वर्ग के सभी उपयोगकर्ताओं को फिर से तैयार किया जाना चाहिए। ऐसी निर्भरता से बचने के लिए, सदस्य कार्यों के लिए एक सूचक का उपयोग किया जाता है, जिसके कार्यान्वयन को छिपाना होगा। इस तकनीक को Pimpl (Pointer to Implementation - Pointer to कार्यान्वयन) कहा जाता है। दो मुख्य नुकसान इस प्रकार हैं:

1. प्रत्येक ऑब्जेक्ट निर्माण के लिए संदर्भित ऑब्जेक्ट के लिए डायनेमिक मेमोरी आवंटन की आवश्यकता होती है
2. एक छिपे हुए ऑब्जेक्ट के सदस्यों तक पहुंचने के लिए अप्रत्यक्ष के कई स्तरों (कम से कम एक) का उपयोग करना

आप क्या छिपाने की कोशिश कर सकते हैं?

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

अब कार्य को थोड़ा जटिल करते हैं। कल्पना करें कि हमारी कक्षा का उपयोग अक्सर किया जाता है, और, जैसा कि आप जानते हैं, ढेर पर गतिशील मेमोरी आवंटन एक बहुत महंगा ऑपरेशन है। छिपी हुई वस्तु के लिए अग्रिम में मेमोरी आवंटित करने का प्रयास करें:

//GeneralSocket.h

Class GeneralSocket

{

public :

GeneralSocket();

void connect();

private :

static const size_t sizeOfImpl = 42; /* or whatever space needed*/

char socket [sizeOfImpl];

}



//GeneralSocket.cxx

#include “UnixSocketImpl.h”



GeneralSocket::GeneralSocket() : {

assert(sizeOfImpl >= sizeof (UnixSocketImpl));

new (&socket[0]) UnixSocketImpl;

}



GeneralSocket::~GeneralSocket() {

(reinterpret_cast<UnixSocketImpl *> (&socket[0]))->~UnixSocketImpl();

}



GeneralSocket::connect() {

socket->connectImpl();

}



* This source code was highlighted with Source Code Highlighter .

हम GeneralSocket हैडर फ़ाइल में UnixSocketImpl वर्ग की घोषणा से छुटकारा पाने और गतिशील मेमोरी आवंटन से छुटकारा पाने में कामयाब रहे। बदले में, हमें कई महत्वपूर्ण कमियां मिलीं:

1. C ++ एक दृढ़ता से टाइप की गई भाषा है, और यह ट्रिक भाषा प्रतिबंधों को दरकिनार करने का एक प्रयास है
2. मेमोरी संरेखण के साथ समस्याएं। यह विधि इस बात की गारंटी नहीं देती है कि मेमोरी को UnixSocketImpl के सभी सदस्यों के लिए ठीक से संरेखित किया जाएगा। एक समाधान जो पूर्ण पोर्टेबिलिटी की गारंटी नहीं देता है, लेकिन फिर भी ज्यादातर मामलों में काम करता है, संघ का उपयोग करना है:
   
   

   union max_align {

void * dummy1;

int dymmy2;

}



union {

max_align m;

char socket [sizeOfImpl];

}



* This source code was highlighted with Source Code Highlighter .
   
   
   
   

   
   
   
3. UnixSocketImpl कार्यों की सावधानीपूर्वक हैंडलिंग। उदाहरण के लिए, अब आपको अपने असाइन किए गए कॉपी ऑपरेटर का उपयोग करना होगा, या डिफ़ॉल्ट ऑपरेटर को अक्षम करना होगा
4. जनरल सॉकेट क्लास के लिए समर्थन अधिक समय लेने वाला बन गया है। अब आपको sizeOfImpl का आकार अद्यतित रखना होगा।
5. अक्षम स्मृति का उपयोग यदि स्थिति का आकारऑफ़आईएमपीएल = = आकार (यूनिक्स सॉकेटआईएमपीएल) केंद्रित नहीं है

जैसा कि आप जानते हैं, एक निश्चित आकार की स्मृति का आवंटन एक अनियंत्रित मात्रा में स्मृति के आवंटन की तुलना में बहुत तेज है। आइए हमारी मेमोरी एलोकेटर का उपयोग करने का प्रयास करें:

//GeneralSocket.h

class GSimpl;



class GeneralSocket {

private :

GSimpl * pimpl;

}



//GeneralSocket.cxx

#include “UnixSocketImpl.h”



class FixedAllocator {

public :

static FixedAllocator* Instance();

void * Allocate(size_t);

void Deallocate( void *);

private :

/*Singleton implementation that allocates memory of fixed size*/

};



struct FastPimpl {



void * operator new ( size_t s) {

return FixedAllocator::Instance()->Allocate(s);

}



void operator delete( void * p) {

FixedAllocator::Instance()->Deallocate(p);

}

};



struct GSimpl : FastPimpl {

/*use UnixSocketImpl here*/

};



GeneralSocket::GeneralSocket() : pimpl ( new GSimpl){}



GeneralSocket::~GeneralSocket() {

delete pimpl;

pimpl = 0;

}



* This source code was highlighted with Source Code Highlighter .

FastPimpl को इनहेरिट करते हुए हम एक निश्चित आकार के मेमोरी एलोकेटर (फिक्स्डअलोकेटर) के साथ आवश्यक बंद वर्ग प्राप्त कर सकते हैं।

संक्षेप में कहना। जब मैं पिंपल का उपयोग कर सकता हूं:

1. जब कार्यान्वयन से अमूर्तन को अलग करना आवश्यक हो। इस मामले में, आवश्यक कार्यान्वयन का चयन किया जा सकता है, उदाहरण के लिए, कार्यक्रम की शुरुआत में
2. जब नई कक्षाओं के साथ अमूर्त और कार्यान्वयन दोनों का विस्तार करना और उन्हें मनमाने ढंग से संयोजित करना आवश्यक है। इस प्रकार, हमें अमूर्तन और कार्यान्वयन की कक्षाओं के दो स्वतंत्र पदानुक्रम मिलते हैं
3. जब कार्यान्वयन बदलते समय क्लाइंट कोड को पुन: उपयोग नहीं किया जाना चाहिए
4. जब आपको क्लाइंट से अमूर्तता के कार्यान्वयन को छिपाने की आवश्यकता होती है

संबंधित लिंक

1. स्टीफन सी। देहर्ुस्त। "फिसलन स्थानों सी ++। अपने कार्यक्रमों को डिज़ाइन और संकलित करते समय समस्याओं से बचना। ”(C ++ गोचैस। कोडिंग और डिज़ाइन में सामान्य समस्याओं से बचना)। "टिप 8"
2. सटर, आंद्रेई अलेक्जेंड्रेस्कु के हथियारों का कोट। "C ++ प्रोग्रामिंग मानक।" "अध्याय 43"
3. ऑब्जेक्ट-ओरिएंटेड डिज़ाइन के रिसेप्शन। डिजाइन पैटर्न, ई। गामा, आर। हेल्म, आर। जॉनसन, जे। विलीसाइड्स। ब्रिज पैटर्न
4. संकलन फ़ायरवॉल (http://gotw.ca/gotw/024.htm)
5. द फास्ट पिम्पल मुहावरे (http://gotw.ca/gotw/028.htm)