C ++ कॉलबैक और अपवाद

परिचय

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





तो, C ++ कोड अपवादों को फेंक सकता है जिसके लिए C कोड तैयार नहीं है। आखिरकार, कॉलबैक फ़ंक्शन को लाइब्रेरी के संदर्भ में निष्पादित किया जाता है। और अगर इस तरह के एक फ़ंक्शन से बाहर निकलना एक अपवाद को फेंककर किया जाता है, तो यह स्टैक को नष्ट करते हुए आगे बढ़ जाएगा।

स्पष्ट समाधान, वह जो मुझे सबसे अधिक बार मिला जब मैंने पहली बार इस मुद्दे से निपटना शुरू किया, इस तरह के कॉलबैक में अपवादों को पूरी तरह से छोड़ देना है। लेकिन यह, ज़ाहिर है, हमारा मामला नहीं है।

मामला

मैंने अच्छे कारण के लिए एक्सपैट का उदाहरण दिया। इस पुस्तकालय का उपयोग करते समय अपवादों की समस्या ठीक-ठीक उत्पन्न हुई। कार्य इस प्रकार था:

• कुछ कोड हैं जो C ++ में लिखे गए xml लाइब्रेरी का उपयोग करते थे और यह कोड सक्रिय रूप से अपवादों का उपयोग करता था;
• बाकी कोड को दोबारा लिखे बिना xml लाइब्रेरी को दूसरे के साथ बदलने की आवश्यकता है।

मैंने एक्सपैक्टर के ऊपर एक रैपर विकसित करने के बारे में निर्धारित किया है, जिसने पिछली लाइब्रेरी के इंटरफ़ेस को दोहराया है। यह इस समस्या को हल करने की प्रक्रिया में था कि यह विचार पैदा हुआ था।

विचार

यह किसी भी तरह अपवाद फेंक को स्थगित करने के लिए आवश्यक है जब तक कि निष्पादन C ++ कोड पर वापस नहीं आता है। एकमात्र तरीका कहीं न कहीं अपवाद को बचाना है और इसे फिर से एक सुरक्षित स्थान पर फेंकना है। लेकिन कार्यान्वयन से जुड़ी कई कठिनाइयाँ हैं।

कार्यान्वयन

कक्षा अपवाद_स्टोर

पहले आपको फेंके गए अपवादों के लिए एक भंडार को लागू करने की आवश्यकता है, यह इतना सरल लगेगा:

class exception_storage

{

public :

inline ~exception_storage() {}

inline exception_storage() {}



void rethrow() const ;



inline void store(clone_base const & exc);

inline bool thrown() const ;

private :

std::auto_ptr< const clone_base> storedExc_;

};





Clone_base वर्ग को बढ़ावा देना है :: अपवाद_detail :: clone_base हमारे उद्देश्य के लिए बहुत उपयुक्त है।

कार्यान्वयन भी जटिल नहीं है:

inline

void exception_storage::store(clone_base const & exc)

{

storedExc_.reset(exc.clone());

}

inline

bool exception_storage::thrown() const

{

return storedExc_.get() != 0;

}

inline

void exception_storage::rethrow()

{

class exception_releaser

{

public :

inline

exception_releaser(std::auto_ptr< const clone_base> & excRef)

: excRef_(excRef)

{}

inline

~exception_releaser()

{

excRef_.reset();

}

private :

std::auto_ptr< const clone_base> & excRef_;

};



if (thrown())

{

volatile exception_releaser dummy(storedExc_);

storedExc_->rethrow();

}

}





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

मैं रेथ्रो विधि के कार्यान्वयन के बारे में भी बात करना चाहूंगा। वर्चुअल फ़ंक्शन रीथ्रो को इसमें कहा जाता है (और यह वह फ़ंक्शन है जिसमें अवधारणा है कि हम अपवाद के साथ वास्तव में क्या उत्पन्न करते हैं)। जब इसे फेंका जाता है, तो अपवाद_releaser वर्ग संग्रहीत अपवाद की मेमोरी को साफ़ करता है। पीढ़ी के दौरान अपवाद कॉपी किया जाता है, इसलिए storeExc_ द्वारा इंगित ऑब्जेक्ट अनावश्यक हो जाता है। इसके अलावा, इसने मुझे पीढ़ी की आवश्यकता को इंगित करने के लिए बुलियन ध्वज पर बचाने की अनुमति दी।

अपवाद फ़िल्टर

इस पूरे सिस्टम के बारे में सबसे मुश्किल बात, मेरी राय में, अपवाद फ़िल्टर है। अद्भुत बढ़ावा :: mpl पुस्तकालय इसके कार्यान्वयन के साथ हमें बहुत मदद करेगा। आइए इसे और अधिक विस्तार से विचार करें।



जाहिर है, रिपॉजिटरी के लिए एक अपवाद लिखने के लिए, आपको पहले इसे पकड़ना होगा। फ़िल्टर को इस समस्या को हल करने के लिए डिज़ाइन किया गया है। एक काल्पनिक कॉलबैक लें:

void callback( void *userData, char const *libText);





इस फ़ंक्शन के दायरे के बाहर अपवादों को कैसे रोका जाए?

पहला उपाय यह है कि हर चीज को रोकना। लेकिन यहाँ हम भाषा के एक कष्टप्रद प्रतिबंध को देखते हैं। आप एक पोर्टेबल तरीके से एक पकड़ने (...) ब्लॉक में अपवाद के प्रकार के बारे में जानकारी प्राप्त नहीं कर सकते। यह तब था कि मेरे पास यह विचार आया कि हम इस सुविधा को कर सकते हैं। लाइब्रेरी उपयोगकर्ता को यह निर्दिष्ट करने में सक्षम करने के लिए कि इन कॉलबैक में क्या अपवाद पकड़े जाने चाहिए।

मैंने एक संकलन-समय एक्स्टेंसिबल अपवाद फ़िल्टर लागू करके शुरू किया। यह इस तरह दिखता है:

template < typename List, size_t i = boost::mpl::size<List>::value - 1>

class exception_filter

{

typedef typename boost::mpl::at_c<List, i>::type exception_type;

public :

static inline void try_(exception_storage & storage)

{

try

{

exception_filter<List, i - 1>::try_(storage);

}

catch (exception_type const & e)

{

storage.store(boost::enable_current_exception(e));

}

}

};

template < typename List>

class exception_filter<List, 0>

{

typedef typename boost::mpl::at_c<List, 0>::type exception_type;

public :

static inline void try_(exception_storage & storage)

{

try

{

throw ;

}

catch (exception_type const & e)

{

storage.store(boost::enable_current_exception(e));

}

}

};





यह एक पुनरावर्ती त्वरित टेम्पलेट है जो सूची पैरामीटर के रूप में बढ़ावा :: mpl :: वेक्टर का उपयोग करता है। वेक्टर में, आप उन अपवादों के प्रकार निर्दिष्ट कर सकते हैं जिन्हें आप पकड़ना चाहते हैं। जब त्वरित किया जाता है, तो टेम्पलेट कुछ इस तरह फैलता है (छद्मकोश):

try

{

try

{

try

{

throw ;

}

catch (exception_type_1)

{

}

}

catch (exception_type_2)

{

}

}

catch (exception_type_N)

{

}





जहाँ N, mpl :: वेक्टर में प्रकारों की संख्या है।

यदि फ़िल्टर अपवाद को जानता है, तो इसे बढ़ावा देने के लिए इसे अपवाद_स्टोरेज में संग्रहीत किया जाता है :: enable_current_exception। Smart_filter फ़ंक्शन टेम्पलेट को नियंत्रित करता है। इसके अलावा, अन्य सभी अपवादों को पकड़ता है जो टाइप सूची में निर्दिष्ट नहीं थे।

template <typename List>

inline void smart_filter(exception_storage & storage)

{

try

{

exception_filter<List>::try_(storage);

}

catch (...)

{

storage.store(boost::enable_current_exception(std::runtime_error("unexpected")));

}

}





परिणाम

अब सी लाइब्रेरी के ऊपर एक रैपर क्लास में इसे संयोजित करने का समय है। विचार प्रदर्शित करने के लिए मैं इसे योजनाबद्ध तरीके से दिखाऊंगा:

template < typename List>

class MyLib

{

public :

MyLib()

{

pureCLibRegisterCallback(&MyLib::callback);

pureCLibSetUserData( this );

}

virtual void doIt()

{

pureCLibDoIt();

storage_.rethrow();

}

protected :

virtual void callback( char const *) = 0;

private :

static void callback( void * userData, char const * libText)

{

if (MyLib<List> * this_ = static_cast <MyLib<List>*>(userData))

{

try

{

this_->callback(libText);

}

catch (...)

{

smart_filter<List>(this_->storage_);

}

}

}

exception_storage storage_;

};





बस इतना ही। अब मैं उपयोग का एक छोटा सा उदाहरण दूंगा।

struct MyClass

: public MyLib <

boost::mpl::vector

<

std::runtime_error,

std::logic_error,

std::exception

>

>

{

private :

void callback( char const * text)

{

throw std::runtime_error(text);

}

};

int main()

{

MyClass my;



try

{

my.doIt();

}

catch (std::exception const & e)

{

std::cout << e.what() << std::endl;

}

return 0;

}





यह कार्यान्वयन एकल-थ्रेडेड परिवेश के लिए अभिप्रेत है।