C ++ वैरेडिक टेम्प्लेट में जिम्मेदारी की श्रृंखला

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

तो मान लें कि हमारे पास एक वस्तु है:

class Elephant { public: std::string touch_leg() { return "it's like a pillar"; } std::string touch_trunk() { return "it's like a snake"; } std::string touch_tail() { return "it's like a rope"; } void run_away() { m_is_gone = true; std::cout << "*** Sound of running out elephant ***\n"; } bool is_elephant_here() { return !m_is_gone; } private: bool m_is_gone = false; }; 

और हमारे पास 3 हैंडलर होंगे, जिनमें से प्रत्येक आगे की वस्तु को पास करेगा:

 //        auto blind_sage3 = ChainOfRepsonsibility::start_new([](Elephant& e) { std::cout << "Third blind sage: " << e.touch_tail() << "\n"; }); // ""    ,     auto blind_sage2 = blind_sage3.attach([](Elephant& e, auto& next) { std::cout << "Second blind sage: " << e.touch_trunk() << "\n"; next(e); }); //    ,     ,    auto blind_sage1 = blind_sage2.attach([](Elephant& e, auto& next) { if (!e.is_elephant_here()) { std::cout << "First blind sage: So empty... so true\n"; } else { std::cout << "First blind sage: " << e.touch_leg() << "\n"; next(e); } }); //      Elephant e; blind_sage1(e); 

इस उदाहरण में, 3 हैंडलर हैं, जिनमें से प्रत्येक एक लैम्ब्डा अभिव्यक्ति है, जो कि चेनऑफ रिप्सनसिटी क्लास का उपयोग करके जिम्मेदारी की श्रृंखला में संयुक्त है।

यहाँ वर्ग कार्यान्वयन स्वयं है:

 #include <functional> struct ChainOfRepsonsibility { template<typename... Args> struct Chain { template<typename Callee, typename Next> Chain(const Callee c, const Next& n) { m_impl = c; m_next = n; } template<typename Callee> decltype(auto) attach(Callee c) { return Chain(c, *this); } void operator()(Args... e) { m_impl(e..., m_next); } std::function<void(Args..., std::function<void(Args...)>)> m_impl; std::function<void(Args...)> m_next; }; template<typename... Args> struct ChainTail { template<typename Callee> ChainTail(Callee c) { m_impl = c; } template<typename Callee> decltype(auto) attach(Callee c) { return Chain<Args...>(c, m_impl); } void operator()(Args... e) { m_impl(e...); } std::function<void(Args... e)> m_impl; }; template<typename> struct StartChain; template<typename C, typename... Args> struct StartChain<void (C::*)(Args...) const> { using Type = ChainTail<Args...>; }; template<typename Callee> static decltype(auto) start_new(Callee c) { return StartChain<decltype(&Callee::operator())>::Type(c); } }; 

यह इस तरह काम करता है:

• सबसे पहले, हम start_new फ़ंक्शन का उपयोग करके जिम्मेदारी की एक श्रृंखला बनाते हैं। इस स्तर पर मुख्य समस्या यह है कि पास हुए लंबो से तर्कों की एक सूची प्राप्त करें और उनके आधार पर हैंडलर का "प्रोटोटाइप" बनाएं।
• लैम्ब्डा के तर्क प्राप्त करने के लिए, स्टार्टचैन क्लास और टेम्प्लेट के विशेषज्ञता के साथ एक मुश्किल विषय का उपयोग किया जाता है। सबसे पहले, हम कक्षा का एक सामान्य संस्करण घोषित करते हैं, और फिर स्पेशलाइजेशन स्ट्रक्चर StartChain <void (C :: *) (Args ...) const> । यह निर्माण हमें पास किए गए कक्षा सदस्य द्वारा तर्क सूची तक पहुंचने की अनुमति देता है।
• तर्कों की एक सूची होने के बाद, हम पहले से ही चेनटेल और चेन क्लास बना सकते हैं, जो हैंडलर के लिए एक आवरण होगा। उनका कार्य ldda को std :: फ़ंक्शन में सहेजना है और इसे सही समय पर कॉल करना है, साथ ही संलग्न पद्धति (ऊपर से हैंडलर सेट करना) को लागू करना है।
  

दृश्य स्टूडियो 2015 पर कोड का परीक्षण किया गया है, gcc के लिए यह आवश्यक हो सकता है कि वहां से कास्ट हटाकर StartChain विशेषज्ञता को ठीक किया जाए, अगर lambdas के अलावा आप बस फ़ंक्शन पास करना चाहते हैं, तो आप एक और StartChain विशेषज्ञता जोड़ सकते हैं। आप अभी भी अनुलग्नक में नकल से छुटकारा पाने की कोशिश कर सकते हैं, कदम बढ़ा सकते हैं, लेकिन उदाहरण को जटिल नहीं करने के लिए, मैंने केवल सबसे सरल मामले को छोड़ दिया।