😃 💒 💆🏽 लिंक या सरल संदेश में स्वतंत्रता के बारे में 🤗 ↘️ 🐁

कम्प्यूटर साइंस में मैसेजिंग एक काफी मौलिक चीज है। हम इसे इवेंट-संचालित प्रोग्रामिंग ( इवेंट-संचालित ) के करीब मानेंगे । शब्दावली, क्षमताएं और कार्यान्वयन अलग हो सकते हैं: ईवेंट ( ईवेंट ), संदेश ( संदेश ), सिग्नल / स्लॉट ( सिग्नल / स्लॉट ) और कॉलबैक । सामान्य तौर पर, सार यह है कि घटना के आगमन के साथ, एक प्रतिक्रिया शुरू हो जाती है।
लेख में मैसेजिंग सिस्टम स्वयं लिंक / पॉइंटर्स की नि: शुल्क लेकिन स्वीकार्य व्याख्या के प्रदर्शन के रूप में कार्य करता है, जिससे कोड सरल हो जाता है। परिणामी प्रणाली तुच्छ है और केवल एक विशिष्ट संदेश कोड के लिए हैंडलर को पंजीकृत कर सकती है और इस तरह के कोड के साथ संदेश भेज सकती है।
मान लीजिए कि हैंडलर नॉनवेज हैं, और कुछ संदेश हैं। और यह कि हम स्वयं संदेश उत्पन्न करते हैं और वे नेटवर्क पर हमारे पास नहीं आते हैं, उदाहरण के लिए। इस मामले में, मैं संदेश में स्पष्ट परिवर्तनशील घोषणाओं के साथ कुछ और सुविधाजनक बनाना चाहता हूं। उदाहरण के लिए, कुछ इस तरह:

StringMessage* str_message = ...; send(my_message); ... void handle_message(const Message* message) { assert(message); const StringMessage* str_message = dynamic_cast<const StringMessage*>(message); assert(str_message); std::cout << str_message->message ... }

लेकिन मैं सत्यापन कोड को हटाना चाहता हूं, काम के तर्क से संबंधित नहीं, हुड के नीचे। इसलिए, हम सूचक को लिंक में बदल देते हैं, यह दिखाते हैं कि ऑब्जेक्ट निश्चित रूप से हैंडलर में आता है, न कि ~~Null~~ nullptr। और हैंडलर को उस संदेश के प्रकार को तुरंत स्वीकार करने दें जो उसे चाहिए।

 void handle_message(const StringMessage& message) { ... }

हमारी योजना को कैसे लागू करें और अन्य संभावित संदेश वर्गों का समर्थन करें?

विचार सरल है। हैंडलर के पंजीकरण के दौरान, हम तर्क के प्रकार का पता लगाते हैं जो इसे लेता है और इसे लिखता है। और संदेश भेजते समय, हम सत्यापित करते हैं कि संदेश प्रकार हैंडलर तर्क के प्रकार से मेल खाता है। प्रत्येक नए संदेश प्रकार के लिए, हमें Message संदेश के आधार वर्ग से विरासत में मिला है।

 class Message{ public: Message(unsigned code) : code(code) {} virtual ~Message() {} const unsigned code; }; enum Code { STRING = 1 }; class StringMessage : public Message { public: StringMessage(const std::string& msg) : Message(STRING), message(msg) {} const std::string message; };

प्रतिनिधियों के साथ निर्णय

अच्छे पुराने प्रतिनिधि C ++ 03 में काम करते हैं। कार्यान्वयन के उदाहरणों में से एक का वर्णन यहाँ हैबे पर किया गया है । इस मामले में प्रतिनिधि केवल सदस्य कार्यों पर एक कार्यात्मक आवरण हैं। यह वही है जो हैंडलर सदस्यता की तरह दिखता है।

 class Messenger { ... template <class T, class MessageDerived> void subscribe(int code, T* object, void (T::* method)(const MessageDerived&)) { //   ,    -  const std::type_index& arg_type = typeid(const MessageDerived); //   ,      (const Message&) void (T::* sign)(const Message&) = (void (T::*)(const MessageDerived&)) method; //    subscribers_.push_back(Subscriber(code, object, NewDelegate(object, sign), arg_type)); } }

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

 template <class Base, class Derived> bool is_sliced(const Derived* der) { return (void*) der != (const Base*) der; }

लेकिन एक संकलन समय की जांच लिखना सबसे अच्छा है। संकलक को विरासत में मिला आधार के अनुसार एक प्रकार का टुकड़ा होगा। और अगर सूचक 1 से बढ़ गया, तो ऑब्जेक्ट काट दिया गया था।

 template <class Base, class Derived> struct is_sliced2 : public std::integral_constant<bool, ((void*)((Base*)((Derived*) 1))) != (void*)1> {}; ... static_assert(!is_sliced2<Message, Arg>::value, "Message object should not be sliced");

दुर्भाग्य से, MSVS 2013 संकलक स्थिति को संकलित करने के साथ सामना नहीं करता है, लेकिन gcc-4.8.1 ठीक है।

संदेश भेजना आसान है। जांचें कि संदेश छोटा नहीं है। हम सभी हैंडलर के माध्यम से चलते हैं। यदि संदेश कोड और हैंडलर मेल खाते हैं, तो हम अनुपालन के प्रकारों की जांच करते हैं। अगर सब कुछ मेल खाता है, तो हैंडलर को बुलाओ।

संदेश भेजना

 class Messenger { ... template <class LikeMessage> void send(const LikeMessage& msg) { assert((!is_sliced<Message, LikeMessage>(&msg))); send_impl(msg); } private: void send_impl(const Message& msg) { const std::type_info& arg = typeid(msg); //     for (SubscribersCI i = subscribers_.begin(); i != subscribers_.end(); ++i) { if (i->code == msg.code) { //    if (arg != i->arg_type) // ,        throw std::logic_error("Bad message cast"); i->method->call(msg); //  -  } } } }

सत्यापन को जोड़ना याद रखना महत्वपूर्ण है कि MessageDerived वास्तव में Message से विरासत में मिला है। C ++ 11 में, <type_traits> फ़ाइल में std::is_base_of । C ++ 03 में, आपको हाथ से संकलन समय लिखना होगा।
प्रतिनिधि उदाहरण सरल है। हैंडलर वर्ग, प्रतिनिधि सदस्यता, और संदेश भेजना:

 class Printer { public: void print(const StringMessage& msg) { std::cout << "Printer received: " << msg.message << std::endl; } }; int main() { Messenger messenger; Printer print; messenger.subscribe(STRING, &print, &Printer::print); messenger.send(StringMessage("Hello, messages!")); return 0; }

प्रतिनिधियों के साथ कोड

C ++ 11

लैम्ब्डा सी ++ 11 में दिखाई दिए। हमारा लक्ष्य सदस्यता प्रक्रिया को बहुत सरल बनाना है:

 messenger.subscribe(STRING, [](const StringMessage& msg) {...});

आप ldda को std::function में लपेट सकते हैं, लेकिन आपको इनपुट तर्क के प्रकार को खोए बिना लैम्ब्डा के प्रकार को जानना होगा। और फिर lambda को कुछ सार्वभौमिक जैसे std::function<void (const Message&)> । लेकिन आप केवल C ++ के लंबोदर के प्रकार का पता नहीं लगा सकते हैं।

लैम्ब्डा के प्रकार का पता लगाएं

 template <typename Function> struct function_traits : public function_traits<decltype(&Function::operator())> {}; template <typename ClassType, typename ReturnType, typename... Args> struct function_traits<ReturnType(ClassType::*)(Args...) const> { typedef ReturnType (*pointer)(Args...); typedef std::function<ReturnType(Args...)> function; };

यहां से उधार लिया गया । एक अतुलनीय, पुनरावर्ती विरासत में मिली चीज़, और एक आंशिक विशेषज्ञता के साथ भी! लेकिन मुद्दा यह है कि प्रत्येक लैम्ब्डा में एक operator() , जिसका उपयोग कॉल के लिए किया जाता है। decltype(&Function::operator()) यह decltype(&Function::operator()) अनुरूप सदस्य फ़ंक्शन के प्रकार में फैलता है। तर्कों को आंशिक रूप से विशिष्ट टेम्पलेट में पारित किया जाता है, जहां फ़ंक्शन पॉइंटर के प्रकार के लिए संबंधित समानार्थक शब्द सेट किए जाते हैं और फ़ंक्शन पॉइंटर के लिए फ़ंक्शन std::function ।

प्रतिनिधि के साथ विकल्प के लिए कोड समान है। केवल लंबोदर के साथ काम करने का तर्क जटिल है।

 template <typename Function> class Messenger { ... void subscribe(int code, Function func) { //      function_traits typedef typename function_traits<Function>::function FType; //  std::function    argument_type (  ) typedef typename FType::argument_type Arg; //  typeid  auto& arg_type = typeid(Arg); // ,     Message //  Arg  .   ,     . typedef std::remove_reference<Arg>::type ArgNoRef; //    static_assert(std::is_base_of<Message, ArgNoRef>::value, "Argument type not derived from base Message"); //         auto ptr = to_function_pointer(func); //        ,    auto pass = (void(*) (const Message&)) ptr; subscribers_.emplace_back(std::move(Subscriber(code, pass, arg_type))); } }

In_function_pointer के अंदर क्या है?

एक लैम्ब्डा को सांख्यिकीय रूप से पॉइंटर प्रकार से संबंधित प्रकार के फ़ंक्शन में परिवर्तित किया जाता है।

 template <typename Function> typename function_traits<Function>::pointer to_function_pointer(Function& lambda) { return static_cast<typename function_traits<Function>::pointer>(lambda); }

टिप्पणी

यह ध्यान देने योग्य है कि कलाकारों को विपरीत दिशा में बनाना बहुत आसान है।

 std::function<void (const Message&)> msg_func = ...; std::function<void (const StringMessage&)> str_func = msg_func; //

यह एक तार्किक व्यवहार है क्योंकि सार्वजनिक उत्तराधिकार का कार्यान्वयन एक रिश्ता है। विशेष रूप से, StringMessage Message । लेकिन दूसरे तरीके से नहीं।

भेजने का कोड लगभग शब्दशः प्रतिनिधि के साथ पार्स कोड को दोहराता है। सभी कोड लंबोदर के साथ ।
यहां हमारा काम खत्म हो रहा है। आप बस रजिस्टर कर सकते हैं, एक संदेश भेज सकते हैं और इसे संसाधित कर सकते हैं।

 int main() { Messenger messenger; messenger.subscribe(STRING, [](const StringMessage& msg) { std::cout << "Received: " << msg.message << std::endl; }); messenger.send(StringMessage("Hello, messages!")); return 0; }

मैं कई तर्कों के लिए कॉलबैक के अधिक सामान्य कार्यान्वयन के साथ एक लेख का लिंक भी प्रदान करूंगा।

प्रदर्शन में गिरावट

देखते हैं कि प्रदर्शन कितना डूब गया है। चलो दो त्वरित दूतों के लिए केवल एक हैंडलर लेते हैं, जिनमें से एक हमारा है और Message से विरासत में प्राप्त किसी भी प्रकार को स्वीकार कर सकता है। और दूसरा वह जो केवल StringMessage स्ट्रिंग वाले संदेश को स्वीकार कर सकता है। हम एक स्थापित संदेश कई 500 मिलियन बार भेजेंगे।

 Msg: 13955ms Str: 1176ms Ratio: 12.0

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

मैं किस बारे में चुप रहा

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

परिणाम

नतीजतन, हमें एक सरल और काफी सुविधाजनक प्रोटोटाइप मैसेजिंग सिस्टम मिला। सभी कोड GitHub पर उपलब्ध है ।

लिंक या सरल संदेश में स्वतंत्रता के बारे में

प्रतिनिधियों के साथ निर्णय

C ++ 11

प्रदर्शन में गिरावट

परिणाम

More articles: