कैसे संकेत और स्लॉट Qt में काम करते हैं (भाग 2)

एक अनुवादक से: यह क्यूटी 5 में संकेतों और स्लॉट्स की आंतरिक वास्तुकला पर ओलिवियर गोफर्ट के एक लेख के अनुवाद का दूसरा भाग है, पहले भाग का अनुवाद यहां है ।

Qt5 में नया सिंटैक्स

नया सिंटैक्स इस तरह दिखता है:

QObject::connect(&a, &Counter::valueChanged, &b, &Counter::setValue); 

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

नए अतिभारित तरीके

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

 QObject::connect(const QObject *sender, PointerToMemberFunction signal, const QObject *receiver, PointerToMemberFunction slot, Qt::ConnectionType type); QObject::connect(const QObject *sender, PointerToMemberFunction signal, PointerToFunction method) QObject::connect(const QObject *sender, PointerToMemberFunction signal, Functor method) 

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

सदस्य समारोह सूचक

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

 //  myFunctionPtr   - //   void     int void (QPoint::*myFunctionPtr)(int); myFunctionPtr = &QPoint::setX; QPoint p; QPoint *pp = &p; (p.*myFunctionPtr)(5); //  p.setX(5); (pp->*myFunctionPtr)(5); //  pp->setX(5); 

सदस्य संकेत और सदस्य फ़ंक्शन संकेत C ++ सबसेट का एक सामान्य हिस्सा है जो आमतौर पर बहुत अधिक उपयोग नहीं किया जाता है और इसलिए कम जाना जाता है। अच्छी खबर यह है कि Qt और इस नए सिंटैक्स का उपयोग करने के लिए आपको इसके बारे में जानने की आवश्यकता नहीं है। आपको केवल यह याद रखना है कि आपको अपने कनेक्शन में सिग्नल के नाम के सामने और उसके स्थान पर क्या चाहिए। आपको जादू संचालकों से निपटने की आवश्यकता नहीं है :: *, *। * या -> *। ये मैजिक ऑपरेटर आपको एक सदस्य फ़ंक्शन को पॉइंटर घोषित करने और इसे एक्सेस करने की अनुमति देते हैं। ऐसे बिंदुओं के प्रकार में रिटर्न प्रकार शामिल है, वह वर्ग जिसमें फ़ंक्शन होता है, सभी तर्कों के प्रकार और फ़ंक्शन के लिए कॉन्स्टेबल निर्दिष्ट करता है।

आप विशेष रूप से शून्य करने के लिए कुछ और के लिए सदस्य फ़ंक्शन को इंगित नहीं कर सकते, क्योंकि उनके पास अलग-अलग आकार हैं। यदि फ़ंक्शन हस्ताक्षर में थोड़ा अलग है, तो आप एक से दूसरे में परिवर्तित नहीं कर पाएंगे। उदाहरण के लिए, यहां तक ​​कि शून्य (MyClass :: *) (int) कॉन्स्टेंस टू void (MyClass :: *) (int) के रूपांतरण की अनुमति नहीं है (आप इसे reinterpret_cast के साथ कर सकते हैं, लेकिन, मानक के अनुसार, अपरिभाषित व्यवहार (अपरिभाषित व्यवहार होगा) ) यदि आप फ़ंक्शन को कॉल करने का प्रयास करते हैं)।

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

प्रकार लक्षण वर्ग: QtPStreet :: FunctionPointer

मुझे आपको QtPStreet :: FunctionPointer प्रकार की संपत्तियों के एक वर्ग से मिलवाते हैं। संपत्ति वर्ग मूल रूप से एक सहायक वर्ग है जो इस प्रकार के बारे में कुछ मेटाडेटा लौटाता है। Qt में एक संपत्ति वर्ग का एक और उदाहरण QTypeInfo है । नए सिंटैक्स के कार्यान्वयन के ढांचे में हमें जो जानने की आवश्यकता है, वह फ़ंक्शन के लिए सूचक के बारे में जानकारी है। टेम्पलेट <टाइपनेम टी> स्ट्रक्चर फंक्शनपॉइंट हमें अपने सदस्यों के माध्यम से टी के बारे में जानकारी देगा:

• ArgumentCount - फ़ंक्शन तर्कों की संख्या का प्रतिनिधित्व करने वाला एक नंबर
• ऑब्जेक्ट - मौजूद है, केवल पॉइंटर्स टू मेंबर फ़ंक्शंस के लिए, यह एक क्लास का एक टाइपराइफ़ है, जिसमें से एक मेंबर्स के लिए पॉइंटर
• तर्क - तर्क की एक सूची का प्रतिनिधित्व करता है, एक मेटाप्रोग्रामिंग सूची का एक प्रकार है
• कॉल (टी एंड फ़ंक्शन, QObject * रिसीवर, शून्य ** आर्ग्स) - एक स्थिर फ़ंक्शन जो मापदंडों के साथ फ़ंक्शन को कॉल करता है

Qt अभी भी C ++ 98 संकलक का समर्थन करता है, जिसका अर्थ है कि हम, दुर्भाग्य से, एक चर संख्या के तर्क के साथ टेम्पलेट्स के लिए समर्थन की आवश्यकता नहीं कर सकते हैं (वैरिएड टेम्पलेट)। दूसरे शब्दों में, हमें अपने फ़ंक्शन को प्रत्येक संख्या के तर्कों के लिए गुणों के एक वर्ग के लिए विशेषज्ञ होना चाहिए। हमारे पास चार प्रकार के विशेषज्ञता हैं: एक फ़ंक्शन के लिए एक नियमित सूचक, एक सदस्य फ़ंक्शन के लिए एक संकेतक, एक निरंतर सदस्य फ़ंक्शन के लिए एक सूचक और फ़ंक्शनलर्स। प्रत्येक प्रकार के लिए, हमें प्रत्येक संख्या के तर्कों के लिए विशेषज्ञता की आवश्यकता है। हमारे पास छह तर्कों के लिए समर्थन है। हमारे पास एक विशेषज्ञता भी है जो एक तर्कपूर्ण संख्या के लिए तर्कों का उपयोग करती है, एक मनमानी संख्या के लिए तर्कों की, यदि संकलक तर्कों की एक चर संख्या के साथ टेम्पलेट्स का समर्थन करता है। FunctionPointer का कार्यान्वयन qobjectdefs_impl.h में स्थित है।

QObject :: कनेक्ट

कार्यान्वयन बहुत सारे बॉयलरप्लेट कोड पर निर्भर करता है। मैं यह सब नहीं समझाऊंगा। यहाँ qobject.h से पहले नए अधिभार के लिए कोड है:

 template <typename Func1, typename Func2> static inline QMetaObject::Connection connect( const typename QtPrivate::FunctionPointer<Func1>::Object *sender, Func1 signal, const typename QtPrivate::FunctionPointer<Func2>::Object *receiver, Func2 slot, Qt::ConnectionType type = Qt::AutoConnection) { typedef QtPrivate::FunctionPointer<Func1> SignalType; typedef QtPrivate::FunctionPointer<Func2> SlotType; //   ,     Q_STATIC_ASSERT_X(int(SignalType::ArgumentCount) >= int(SlotType::ArgumentCount), ""The slot requires more arguments than the signal provides.""); Q_STATIC_ASSERT_X((QtPrivate::CheckCompatibleArguments<typename SignalType::Arguments, typename SlotType::Arguments>::value), ""Signal and slot arguments are not compatible.""); Q_STATIC_ASSERT_X((QtPrivate::AreArgumentsCompatible<typename SlotType::ReturnType, typename SignalType::ReturnType>::value), ""Return type of the slot is not compatible with the return type of the signal.""); const int *types; /* ...   ,   QueuedConnection ...*/ QtPrivate::QSlotObjectBase *slotObj = new QtPrivate::QSlotObject<Func2, typename QtPrivate::List_Left<typename SignalType::Arguments, SlotType::ArgumentCount>::Value, typename SignalType::ReturnType>(slot); return connectImpl(sender, reinterpret_cast<void **>(&signal), receiver, reinterpret_cast<void **>(&slot), slotObj, type, types, &SignalType::Object::staticMetaObject); } 

आपने फ़ंक्शन हस्ताक्षर में देखा कि प्रेषक और रिसीवर केवल QObject * नहीं हैं जैसा कि दस्तावेज इंगित करता है। ये वास्तव में फंक्शनपाइंटर टाइप करने के लिए पॉइंटर्स हैं :: ऑब्जेक्ट। एक अधिभार बनाने के लिए जो केवल सदस्य कार्यों के लिए संकेत के लिए शामिल है, SFINAE का उपयोग किया जाता है क्योंकि ऑब्जेक्ट फ़ंक्शन फ़ंक्शन में मौजूद होता है केवल यदि प्रकार सदस्य फ़ंक्शन के लिए एक सूचक है।

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

अगला, हम QSlotObject का एक उदाहरण बनाते हैं, जिसे बाद में connectImpl () में पास किया जाएगा। QSlotObject स्लॉट पर एक आवरण है जो इसे कॉल करने में मदद करेगा। वह संकेत तर्कों के प्रकार को भी जानती है और एक उपयुक्त प्रकार का रूपांतरण कर सकती है। हम List_Left का उपयोग केवल स्लॉट में उतने ही तर्कों को पारित करने में करते हैं, जो हमें एक स्लॉट से सिग्नल को कनेक्ट करने की अनुमति देता है, जिसमें सिग्नल की तुलना में कम तर्क होते हैं।

QObject :: connectImpl एक निजी आंतरिक फ़ंक्शन है जो कनेक्शन का प्रदर्शन करेगा। इसमें मूल के समान एक सिंटैक्स होता है, इस अंतर के साथ कि क्यूओबजेक्टपाइंट :: कनेक्शन संरचना में विधि सूचकांक को संग्रहीत करने के बजाय, हम क्यूएसलॉटबजेक्टबेस के लिए एक पॉइंटर को स्टोर करते हैं।

यदि हम शून्य के रूप में पास और स्लॉट करते हैं, तो इसकी तुलना करने में सक्षम होने में सक्षम है यदि प्रकार Qt :: UniqueConnection है। हम शून्य और ** के रूप में भी संकेत देते हैं। यह एक पॉइंटर को पॉइंटर से मेम्बर फंक्शन के लिए पॉइंटर है।

संकेत सूचकांक

हमें सिग्नल पॉइंटर और सिग्नल इंडेक्स के बीच संबंध बनाने की जरूरत है। हम इसके लिए MOC का उपयोग करते हैं। हां, इसका मतलब यह है कि यह नया सिंटैक्स अभी भी एमओसी का उपयोग करता है और इससे छुटकारा पाने की कोई योजना नहीं है :-)। MOC qt_static_metacall में कोड जनरेट करेगा, जो पैरामीटर की तुलना करता है और सही इंडेक्स देता है। ConnectImpl एक सूचक को फ़ंक्शन पॉइंटर के साथ qt_static_metacall फ़ंक्शन को कॉल करेगा।

 void Counter::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a) { if (_c == QMetaObject::InvokeMetaMethod) { /* ....  ....*/ } else if (_c == QMetaObject::IndexOfMethod) { int *result = reinterpret_cast<int *>(_a[0]); void **func = reinterpret_cast<void **>(_a[1]); { typedef void (Counter::*_t)(int ); if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Counter::valueChanged)) { *result = 0; } } { typedef QString (Counter::*_t)(const QString & ); if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Counter::someOtherSignal)) { *result = 1; } } { typedef void (Counter::*_t)(); if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Counter::anotherSignal)) { *result = 2; } } } } 

अब जब हमारे पास सिग्नल इंडेक्स है, तो हम पिछले एक के समान सिंटैक्स के साथ काम कर सकते हैं।

QSlotObjectBase

QSlotObjectBase ConnectImpl के लिए एक वस्तु है जो स्लॉट को दर्शाता है। वर्तमान कोड दिखाने से पहले, यहाँ QObject :: QSlotObjectBase है, जो Qt5 अल्फा में था:

 struct QSlotObjectBase { QAtomicInt ref; QSlotObjectBase() : ref(1) {} virtual ~QSlotObjectBase(); virtual void call(QObject *receiver, void **a) = 0; virtual bool compare(void **) { return false; } }; 

यह मूल रूप से एक इंटरफ़ेस है जिसे कॉलिंग वर्गों के माध्यम से फिर से लागू करने के लिए डिज़ाइन किया गया है जो कॉलिंग और फ़ंक्शन पॉइंटर्स की तुलना करते हैं। इसे टेम्पलेट क्लासेस QSlotObject, QStaticSlotObject या QFunctorSlotObject में से एक द्वारा कार्यान्वित किया जाता है।

नकली वर्चुअल टेबल

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

 class QSlotObjectBase { QAtomicInt m_ref; typedef void (*ImplFn)(int which, QSlotObjectBase* this_, QObject *receiver, void **args, bool *ret); const ImplFn m_impl; protected: enum Operation { Destroy, Call, Compare }; public: explicit QSlotObjectBase(ImplFn fn) : m_ref(1), m_impl(fn) {} inline int ref() Q_DECL_NOTHROW { return m_ref.ref(); } inline void destroyIfLastRef() Q_DECL_NOTHROW { if (!m_ref.deref()) m_impl(Destroy, this, 0, 0, 0); } inline bool compare(void **a) { bool ret; m_impl(Compare, this, 0, a, &ret); return ret; } inline void call(QObject *r, void **a) { m_impl(Call, this, r, a, 0); } }; 

m_impl एक नियमित फ़ंक्शन पॉइंटर है जो तीन ऑपरेशन करता है जो पहले पिछले वर्चुअल फ़ंक्शन थे। बार-बार क्रियान्वयन निर्माणकर्ता में काम करने के लिए निर्धारित किया जाता है।

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

संरक्षित, खुला और बंद संकेत

संकेत Qt4 और पहले में संरक्षित थे। यह एक डिजाइन विकल्प था कि संकेतों को किसी वस्तु द्वारा प्रेषित किया जाना चाहिए जब उसका राज्य बदलता है। उन्हें ऑब्जेक्ट के बाहर से नहीं बुलाया जाना चाहिए, और किसी अन्य ऑब्जेक्ट से सिग्नल कॉल करना लगभग हमेशा एक बुरा विचार है।

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

Qt5 में, हमें सिग्नल को संरक्षित करने से खोलने के लिए बदलना होगा। दुर्भाग्य से, इसका मतलब है कि हर कोई संकेतों का उत्सर्जन कर सकता है। हमें इसे ठीक करने का कोई तरीका नहीं मिला। हमने emit कीवर्ड के साथ ट्रिक की कोशिश की। हमने विशेष अर्थ लौटाने की कोशिश की। लेकिन कुछ भी काम नहीं आया। मुझे विश्वास है कि नए सिंटैक्स के लाभ समस्याओं को दूर करेंगे जब सिग्नल अब खुले हैं।

कभी-कभी सिग्नल बंद होना भी उचित है। यह मामला है, उदाहरण के लिए, QAbstractItemModel में, जहां अन्यथा, डेवलपर्स एक व्युत्पन्न वर्ग में एक संकेत उत्सर्जित करते हैं जो कि एपीआई नहीं चाहता है। उन्होंने एक प्रीप्रोसेसर चाल का उपयोग किया जिससे सिग्नल बंद हो गए, लेकिन नए कनेक्शन सिंटैक्स को तोड़ दिया।

एक नया हैक शुरू किया गया था। QPStreetSignal एक खाली संरचना है जिसे Q_OBJECT मैक्रो में बंद घोषित किया गया है। इसका उपयोग सिग्नल के अंतिम पैरामीटर के रूप में किया जा सकता है। चूंकि यह बंद है, केवल ऑब्जेक्ट को सिग्नल को कॉल करने के लिए इसे बनाने का अधिकार है। हस्ताक्षर की जानकारी बनाते समय MOC अंतिम QPStreetSignal तर्क की अनदेखी करेगा । उदाहरण के लिए qabbriditemmodel.h देखें।

अधिक बॉयलरप्लेट कोड

बाकी कोड qobjectdefs_impl.h और qobject_impl.h में है । यह मूल रूप से बोरिंग बॉयलर कोड है। मैं अब इस पोस्ट के विवरण में गहराई से नहीं जाऊंगा, लेकिन मैं कुछ बिंदुओं पर जाऊंगा जो ध्यान देने योग्य हैं।

मेटाप्रोग्रामिंग सूची

जैसा कि पहले कहा गया है, फंक्शनपॉइंट :: तर्क तर्क की एक सूची है। कोड को इस सूची के साथ काम करना चाहिए: तत्व द्वारा पुनरावृति तत्व, इसका केवल एक हिस्सा मिलता है, या इस तत्व का चयन करें। यही कारण है कि QtPrivate :: सूची को प्रकारों की सूची के रूप में दर्शाया जा सकता है। इसके लिए कुछ सहायक कक्षाएं QtPStreet :: List_Select और QtPStreet :: List_Left हैं, जो सूची में Nth तत्व और पहले N तत्वों वाली सूची का हिस्सा लौटाते हैं।

सूची का कार्यान्वयन कंपाइलरों के लिए अलग है जो मापदंडों की एक चर संख्या के साथ टेम्पलेट्स का समर्थन करते हैं और जो उनका समर्थन नहीं करते हैं। मापदंडों की एक चर संख्या के साथ टेम्पलेट्स के साथ:

 template<typename... T> struct List; 

तर्क सूची बस टेम्पलेट मापदंडों को छुपाती है। उदाहरण के लिए, तर्कों वाली सूची (int, Qstring, QObject *) इस प्रकार होगी:

 List<int, QString, QObject *> 

मापदंडों की एक चर संख्या के साथ टेम्पलेट्स के बिना, यह LISP शैली में दिखेगा:

 template<typename Head, typename Tail > struct List; 

जहां सूची के अंत के लिए टेल कोई अन्य सूची या शून्य हो सकता है। इस मामले में पिछला उदाहरण इस प्रकार है:

 List<int, List<QString, List<QObject *, void>>> 

ApplyReturnValue ट्रिक

FunctionPointer :: कॉल फ़ंक्शन में, स्लॉट का रिटर्न वैल्यू प्राप्त करने के लिए args [0] का उपयोग किया जाता है। यदि संकेत एक मान लौटाता है, तो यह संकेत के वापसी मूल्य के प्रकार के साथ किसी वस्तु के लिए एक संकेतक होगा, अन्यथा 0. यदि स्लॉट एक मान लौटाता है, तो हमें इसे arg [0] पर कॉपी करना होगा। यदि यह शून्य है, तो हम कुछ नहीं करते हैं।

समस्या यह है कि किसी ऐसे फ़ंक्शन के रिटर्न मान का उपयोग करना सिंटैक्टिक रूप से गलत है जो शून्य देता है। क्या मुझे भारी मात्रा में कोड डुप्लिकेट करना है: एक बार शून्य के वापसी मूल्य के लिए और दूसरा शून्य के अलावा किसी अन्य मूल्य के लिए? नहीं, अल्पविराम ऑपरेटर के लिए धन्यवाद।

C ++ में, आप यह कर सकते हैं:

 functionThatReturnsVoid(), somethingElse(); 

आप अल्पविराम के साथ अल्पविराम को बदल सकते हैं और यह सब अच्छा होगा। यह दिलचस्प हो जाता है जब आप इसे शून्य के अलावा किसी अन्य चीज़ से कहते हैं:

 functionThatReturnsInt(), somethingElse(); 

यहां, अल्पविराम वह कथन होगा, जिसे आप अधिभार भी दे सकते हैं। यह वह है जो हम qobjectdefs_impl.h में करते हैं :

 template <typename T> struct ApplyReturnValue { void *data; ApplyReturnValue(void *data_) : data(data_) {} }; template<typename T, typename U> void operator,(const T &value, const ApplyReturnValue<U> &container) { if (container.data) *reinterpret_cast<U*>(container.data) = value; } template<typename T> void operator,(T, const ApplyReturnValue<void> &) {} 

ApplyReturnValue केवल शून्य पर एक आवरण है *। अब, इसका उपयोग वांछित सहायक इकाई में किया जा सकता है। यहां बिना किसी दलील के एक फ़नकार के लिए एक उदाहरण मामला है:

 static void call(Function &f, void *, void **arg) { f(), ApplyReturnValue<SignalReturnType>(arg[0]); } 

यह कोड इनलाइन है, इसलिए यह रनटाइम में प्रदर्शन के मामले में कुछ भी खर्च नहीं करेगा।