🤶🏻 👌🏾 🥦 बूस्ट सिग्नल - सी ++ के लिए सिग्नल और स्लॉट 🎏 🤶🏿 👎🏽

यह लेख किस बारे में है

आज मैं बूस्ट सिग्नल लाइब्रेरी के बारे में बात करूंगा - सिग्नल, स्लॉट, कनेक्शन और उनका उपयोग करने के तरीके के बारे में।

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

सरल उदाहरण है

मान लीजिए कि हम गेम के लिए UI बनाते हैं। हमारे पास खेल में कई बटन होंगे, और प्रत्येक बटन दबाने पर कुछ कार्य करेगा। और मैं एक ही समय में चाहूंगा कि सभी बटन एक ही बटन प्रकार के हों - यानी, आपको उस कोड से बटन को अलग करना होगा जिसे उस पर क्लिक करके निष्पादित किया गया है। बस ऐसे अलगाव के लिए संकेतों की जरूरत होती है।

एक संकेत बहुत सरलता से घोषित किया जाता है। इसे वर्ग के सदस्य के रूप में घोषित करें:

#include "boost/signals.hpp" class Button { public: boost::signal<void()> OnPressed; // };

यहां हम एक संकेत बनाते हैं जो कोई पैरामीटर नहीं लेता है और मान वापस नहीं करता है।
अब हम एक स्लॉट को इस सिग्नल से जोड़ सकते हैं। एक स्लॉट के रूप में फ़ंक्शन का उपयोग करने का सबसे आसान तरीका है:

 void FunctionSlot() { std::cout<<"FunctionSlot called"<<std::endl; } ... Button mainButton; mainButton.OnPressed.connect(&FunctionSlot); //

फ़ंक्शन के अतिरिक्त, आप एक कार्यात्मक ऑब्जेक्ट भी कनेक्ट कर सकते हैं:

 struct FunctionObjectSlot { void operator()() { std::cout<<"FunctionObjectSlot called"<<std::endl; } }; ... //   mainButton.OnPressed.connect(FunctionObjectSlot());

कभी-कभी, यदि बहुत कम कोड है, तो अनाम फ़ंक्शन लिखना और इसे तुरंत कनेक्ट करना अधिक सुविधाजनक है:

 //   mainButton.OnPressed.connect([]() { std::cout<<"Anonymous function is called"<<std::endl; });

यदि आपको किसी ऑब्जेक्ट विधि को कॉल करने की आवश्यकता है, तो आप इसे बढ़ावा देकर भी कनेक्ट कर सकते हैं :: बाइंड सिंटैक्स:

 #include "boost/bind.hpp" class MethodSlotClass { public: void MethodSlot() { std::cout<<"MethodSlot is called"<<std::endl; } }; ... MethodSlotClass methodSlotObject; //  mainButton.OnPressed.connect(boost::bind(&MethodSlotClass::MethodSlot, &methodSlotObject));

बूस्ट बिंद के बारे में, मैं शायद एक अलग लेख लिखूंगा।
इस प्रकार, हमने एक ही बार में कई स्लॉट्स को सिग्नल से जोड़ा। सिग्नल भेजने के लिए, आपको सिग्नल के लिए ब्रैकेट ऑपरेटर () को कॉल करना होगा:

 mainButton.OnPressed();

इस मामले में, स्लॉट्स को उस क्रम में बुलाया जाएगा जो वे जुड़े हुए हैं। हमारे मामले में, आउटपुट इस तरह होगा:

फंक्शन स्लॉट कहा जाता है
FunctionObjectSlot कहा जाता है
अनाम फ़ंक्शन को कहा जाता है
MethodSlot कहा जाता है

मापदंडों के साथ संकेत

सिग्नल में पैरामीटर हो सकते हैं। यहाँ एक उदाहरण स्लॉट घोषणा है जिसमें पैरामीटर हैं:

 boost::signal<void(int, int)> SelectCell;

इस मामले में, स्पष्ट रूप से, कार्य मापदंडों के साथ होना चाहिए:

 void OnPlayerSelectCell(int x, int y) { std::cout<<"Player selected cell: "<<x<<", "<<y<<std::endl; } //   : SelectCell.connect(&OnPlayerSelectCell); // : SelectCell.connect([](int x, int y) { std::cout<<"Player selected cell: "<<x<<", "<<y<<std::endl; }); //   : SelectCell(10, -10);

वस्तुओं को वापस करने के संकेत

सिग्नल वस्तुओं को वापस कर सकते हैं। इसके साथ एक सूक्ष्मता जुड़ी हुई है - यदि कई स्लॉट्स को कॉल किया जाता है, तो वास्तव में, वास्तव में, कई ऑब्जेक्ट वापस आ जाते हैं, है ना? लेकिन संकेत, बदले में, केवल एक वस्तु वापस कर सकता है। डिफ़ॉल्ट रूप से, सिग्नल अंतिम स्लॉट से प्राप्त हुई वस्तु को वापस करता है। हालाँकि, हम अपने स्वयं के "एग्रीगेटर" को संकेत में संचारित कर सकते हैं, जो लौटी हुई वस्तुओं को एक में मिला देगा।

बेशक, मुझे ऐसी स्थिति का सामना नहीं करना पड़ा है जहां मुझे एक संकेत से मूल्यों को वापस करने की आवश्यकता है, लेकिन ओह अच्छी तरह से। मान लीजिए, हमारे मामले में, सिग्नल स्लॉट्स को कॉल करता है जो स्ट्रिंग्स को वापस करता है, और सिग्नल को इन स्ट्रिंग्स से चिपके एक स्ट्रिंग को वापस करना चाहिए।
इस तरह के एक एग्रीगेटर को बस लिखा जाता है - आपको टेम्पलेट ऑपरेटर "कोष्ठक" के साथ एक संरचना बनाने की आवश्यकता होती है जो पुनरावृत्तियों को पैरामीटर के रूप में लेती है:

 struct Sum { template<typename InputIterator> std::string operator()(InputIterator first, InputIterator last) const { //  -   : if (first == last) { return std::string(); } // -   : std::string sum; while (first != last) { sum += *first; ++first; } return sum; } }; //  : auto f1 = []() -> std::string { return "Hello "; }; auto f2 = []() -> std::string { return "World!"; }; boost::signal<std::string(), Sum> signal; signal.connect(f1); signal.connect(f2); std::cout<<signal()<<std::endl; // "Hello World!"

म्यूट सिग्नल

स्लॉट से सभी संकेतों को डिस्कनेक्ट करने के लिए, आपको डिस्कनेक्ट_अल_लॉट विधि को कॉल करना होगा।
एक अलग स्लॉट को प्रबंधित करने के लिए, आपको स्लॉट कनेक्ट करते समय एक अलग प्रकार का बढ़ावा :: कनेक्शन बनाना होगा।
उदाहरण:

 //   mainButton.OnPressed.disconnect_all_slots(); //    FunctionSlot boost::signals::connection con = mainButton.OnPressed.connect(&FunctionSlot); //  if (con.connected()) { //FunctionSlot   . mainButton.OnPressed(); // "FunctionSlot called" } con.disconnect(); //   mainButton.OnPressed(); //

सिग्नल कॉलिंग प्रक्रिया

मुझे नहीं पता कि यह कब काम आ सकता है, लेकिन स्लॉट्स कनेक्ट करते समय, आप कॉल के क्रम को निर्दिष्ट कर सकते हैं:

 mainButton.OnPressed.connect(1, &FunctionSlot); mainButton.OnPressed.connect(0, FunctionObjectSlot()); mainButton.OnPressed(); //  "FunctionObjectSlot called",   "FunctionSlot called"

निष्कर्ष

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

बूस्ट सिग्नल - सी ++ के लिए सिग्नल और स्लॉट