सी ++ के मुहावरे। स्थैतिक आगंतुक

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

आगंतुक

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

class abstract_file_t { public: virtual std::string name() const = 0; virtual void accept(visitor_t& v) = 0; virtual ~abstract_file_t(){} }; //////////////////////////////////////////////////////////////////////////// class regular_file_t : public abstract_file_t { public: std::string name() const; void accept(visitor_t& v); size_t size(); }; //////////////////////////////////////////////////////////////////////////// typedef std::vector<abstract_file_t*> file_vector_t; class directory_t : public abstract_file_t { public: void accept(visitor_t& v); std::string name() const; file_vector_t& files(); }; 

जैसा कि आप देख सकते हैं, फ़ाइल सिस्टम ऑब्जेक्ट्स के बारे में ज्ञान कि वे उनके साथ कैसे काम करेंगे, केवल इस तथ्य में शामिल हैं कि आधार विज़िटर_ट प्रकार के साथ एक ऑब्जेक्ट उन्हें "विज़िट" कर सकता है । स्वीकार समारोह में, हम बस "आगंतुक को अंदर आने देते हैं":

 void regular_file_t::accept(visitor_t& v) {v.visit(*this);} 

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

 class visitor_t { public: virtual void visit(regular_file_t& f) = 0; virtual void visit(directory_t& dir) = 0; virtual ~visitor_t(){} }; class print_info_visitor_t : public visitor_t { public: void visit(regular_file_t& f); { std::cout << "visiting concrete file. file name: " << f.name() << " file size: " << f.size() << std::endl; } void visit(directory_t& dir) { std::cout << "visiting directory. directory name: " << dir.name() << ". contains " << dir.files().size() << “files” << std::endl; } }; 

स्थैतिक आगंतुक

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

 class person_t { public: person_t(const std::string& name, size_t age) : name_(name), age_(age){} template<typename Visitor> void accept(Visitor& v) {v.visit(*this);} size_t age() const {return age_;} private: std::string name_; size_t age_; }; //////////////////////////////////////////////////////////////////////////////// struct person_visitor_t { person_visitor_t(size_t age_limit) : age_limit_(age_limit){} bool operator()(const person_t& p) {return visit(p);} bool visit(const person_t& p) {return p.age() < age_limit_;} size_t age_limit_; }; //////////////////////////////////////////////////////////////////////////////// int main() { std::vector<person_t> person_vec; person_vec.push_back(person_t("Person 1", 43)); person_vec.push_back(person_t("Person 2", 20)); auto it = std::find_if( person_vec.begin(), person_vec.end(), person_visitor_t(30)); if(it != person_vec.end()) std::cout << it->age() << std::endl; return 0; } 

पहले अध्याय में हमने जो देखा, वह बहुत हद तक वैसा ही है?

उपयोग के उदाहरण

ग्राफ पुस्तकालय को बढ़ावा देना

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

 template<typename T> struct node_t { node_t(){} //   accept template<typename V> void on_init(V& v) {v.on_init(t_);} //   accept template<typename V> void on_print(V& v) {v.on_print(t_);} T t_; }; 

एल्गोरिदम। एक डिफ़ॉल्ट संस्करण और एक आगंतुक का उपयोग कर रहा है

 template<typename T, typename Graph> void generate_graph(Graph& g, size_t size); template<typename T, typename Graph, typename Visitor> void generate_graph(Graph& g, Visitor& v, size_t size) { for(size_t i = 0; i < size; ++i) { node_t<T> node; node.on_init(v); g.push_back(node); } } //////////////////////////////////////////////////////////////////////////////// template<typename Graph> void print_graph(Graph& g); template<typename Graph, typename Visitor> void print_graph(Graph& g, Visitor& v) { for(size_t i = 0; i < g.size(); ++i) { g[i].on_print(v); } } 

अब उपयोगकर्ता कोड।

 struct person_t { std::string name; int age; }; //////////////////////////////////////////////////////////////////////////////// // visitor struct person_visitor_t { // visit() void on_init(person_t& p) { p.name = "unknown"; p.age = 0; } // visit() void on_print(const person_t& p) { std::cout << p.name << ", " << p.age << std::endl; } }; //////////////////////////////////////////////////////////////////////////////// int main() { person_visitor_t person_visitor; typedef std::vector<node_t<person_t> > person_vec_t; person_vec_t graph; generate_graph<person_t>(graph, person_visitor, 10); print_graph(graph, person_visitor); } 

प्रकार

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

  template< typename T1 = default_param1, typename T2 = default_param2, typename T3 = default_param3 > class variant { ... public: //     accept() template<typename Visitor> void apply_visitor(const Visitor& v) { switch(type_tag_) //       { case 1: apply1(v, T1()); break; case 2: apply2(v, T2()); break; case 3: apply3(v, T3()); break; default: break; } } }; 

लागू फ़ंक्शन इस तरह दिख सकते हैं

  template<typename Visitor, typename U> void apply1( const Visitor& v, U u, typename std::enable_if< !std::is_same<U, default_param1>::value>::type* = 0) { // data_ -  . //   visit()  operator() v(*(T1*)(&data_[0])); } //     . template<typename Visitor, typename U> void apply1( const Visitor& v, U u, typename std::enable_if< std::is_same<U, default_param1>::value>::type* = 0) { } 

यहां हम SFINAE का उपयोग वर्तमान प्रकार के लिए सही फ़ंक्शन को "सक्षम" करने के लिए करते हैं और डिफ़ॉल्ट रूप से वर्ग मापदंडों के लिए "अक्षम" करते हैं। उपयोगकर्ता कोड काफी सरल है:

 struct visitor_t { void operator()(int i)const ; void operator()(double d)const; void operator()(const std::string& s)const; }; variant<int, double> test_v(34); test_v.apply_visitor(visitor_t());