🗞️ ✊🏿 ⏮️ सी ++ और पायथन का संयोजन। बूस्ट.पाइथन की सूक्ष्मताएं। भाग दो 👝 🐤 🐸

यह लेख पहले भाग की एक निरंतरता है।
लगातार बढ़ रहा है बूस्ट.पायथॉन। इस बार क्लास की बारी है, जिसे न तो बनाया जा सकता है और न ही कॉपी किया जा सकता है।
हम एक असामान्य कंस्ट्रक्टर के साथ लगभग एक सामान्य सांची संरचना लपेटते हैं।
और हम C ++ ऑब्जेक्ट के क्षेत्र के संदर्भ को वापस करने के साथ काम करेंगे, ताकि पायथन कचरा कलेक्टर अनजाने में इसे हटा न दे। और इसके विपरीत, हम जो संग्रहित किया गया है उसे हटाने के बाद कचरे को साफ करने के लिए पायथन के लिए एक विकल्प तैयार करेंगे।
आइए जाने ...

सामग्री की तालिका

हम एक प्रोजेक्ट तैयार कर रहे हैं

हमारे उद्देश्यों के लिए, पिछले भाग से शेष उदाहरण परियोजना को पूरक करना काफी है।
चलो एकल वर्ग के साथ काम करने के लिए इसमें कुछ और फाइलें जोड़ें:
single.h
single.cpp
और अजगर में लपेटने के लिए सहायक कार्यों की घोषणाओं को एक अलग फाइल में डालें:
wrap.h

एक फ़ाइल पिछले प्रोजेक्ट से बनी होनी चाहिए, जिसे हम सक्रिय रूप से बदलेंगे:
wrap.cpp
और एक अद्भुत वर्ग के साथ अद्भुत फाइलें जिन्होंने हमें पहले भाग में इतनी मदद की, वे वैसे ही रहेंगे जैसे कि वे हैं:
some.h
some.cpp

एक साधारण संरचना लपेटें

शुरुआत करने के लिए, आइए सिंगल.एच में एक छोटी सी-शैली की संरचना बनाएं, बस खेतों के विवरण के साथ।
मज़े के लिए, मान लें कि यह केवल एक संरचना नहीं होगी, बल्कि कुछ रहस्यमय प्रकार का कॉन्फ़िगरेशन विवरण होगा:

struct Config { double coef; string path; int max_size; Config( double def_coef, string const& def_path, int def_max_size ); };

ऐसी संरचना के लिए एक आवरण बनाना मुश्किल नहीं है, आपको बस विशेष रूप से निर्माता के साथ निर्माण का वर्णन करने की आवश्यकता है, जिसमें रचनाकार टेम्पलेट बढ़ावा :: python :: init <...> (...) को बढ़ावा देने के लिए पैरामीटर का उपयोग किया गया है :: python - आवरण आवरण टेम्पलेट:

  class_<Config>( "Config", init<double,string,int>( args( "coef", "path", "max_size" ) ) .add_property( "coef", make_getter( &Config::coef ), make_setter( &Config::coef ) ) .add_property( "path", make_getter( &Config::path ), make_setter( &Config::path ) ) .add_property( "max_size", make_getter( &Config::max_size ), make_setter( &Config::max_size ) ) ;

जैसा कि आप देख सकते हैं, आपको यहां स्ट्रिंग क्षेत्र के लिए return_value_policy <copy_const_reference> का उपयोग नहीं करना है। सिर्फ इसलिए कि यहां का क्षेत्र अनिवार्य रूप से मूल्य से लिया गया है, और इसलिए स्वचालित रूप से पायथन भाषा के मानक स्ट्रिंग में परिवर्तित हो गया है।
Make_setter फ़ंक्शंस इनपुट वैल्यू के प्रकार की जांच करने का एक बहुत ही उपयोगी काम करते हैं, उदाहरण के लिए, अजगर में कॉफ़ फ़ील्ड के लिए एक स्ट्रिंग प्रकार मान असाइन करने का प्रयास करें या एक फ़्लोट मान के लिए max_size सेट करें, एक अपवाद प्राप्त करें।
कॉन्फ़िगरेशन संरचना के फ़ील्ड अनिवार्य रूप से एक पूर्ण-पायथन वर्ग कॉन्फ़िगरेशन के ऑब्जेक्ट के गुणों में परिवर्तित हो जाते हैं। खैर, लगभग पूर्ण-भाग ... चलो, पिछले अध्याय से कुछ वर्ग के साथ सादृश्य द्वारा, आवरण के लिए __str__ और __repr__ विधियों को जोड़ते हैं, और साथ ही संरचना फ़ील्ड्स को मानक पायथन के लिए परिवर्तित करने के लिए as_dict गुण जोड़ते हैं और इसके विपरीत।
नए कार्यों की घोषणा, साथ ही पुराने वाले, हमारी नई लपेट में स्थानांतरित कर दिए जाएंगे। h फाइल:

 #pragma once #include <boost/python.hpp> #include "some.h" #include "single.h" using namespace boost::python; string Some_Str( Some const& ); string Some_Repr( Some const& ); dict Some_ToDict( Some const& ); void Some_FromDict( Some&, dict const& ); string Config_Str( Config const& ); string Config_Repr( Config const& ); dict Config_ToDict( Config const& ); void Config_FromDict( Config&, dict const& );

रैप.कैप फाइल में कुछ भी अतिश्योक्तिपूर्ण नहीं होगा और तुरंत उदाहरण मॉड्यूल की घोषणा होगी, जो स्पष्ट रूप से पठनीयता को जोड़ देगा।
Wra.cpp के अंत में, हम अपने नए कार्यों के कार्यान्वयन को लिखेंगे, जिस तरह से हमने उन्हें पहले भाग में लिखा था:

 string Config_Str( Config const& config ) { stringstream output; output << "{ coef: " << config.coef << ", path: '" << config.path << "', max_size: " << config.max_size << " }"; return output.str(); } string Config_Repr( Config const& config ) { return "Config: " + Config_Str( config ); } dict Config_ToDict( Config const& config ) { dict res; res["coef"] = config.coef; res["path"] = config.path; res["max_size"] = config.max_size; return res; } void Config_FromDict( Config& config, dict const& src ) { if( src.has_key( "coef" ) ) config.coef = extract<double>( src["coef"] ); if( src.has_key( "path" ) ) config.path = extract<string>( src["path"] ); if( src.has_key( "max_size" ) ) config.max_size = extract<int>( src["max_size"] ); }

बेशक, मैं पहले से ही वसा के साथ एमोक चल रहा हूं, लेकिन हम इसे अतीत की पुनरावृत्ति कहेंगे।
बेशक, हम संरचना आवरण में नई घोषणाएं जोड़ते हैं:

  class_<Config>( "Config", init<double,string,int>( args( "coef", "path", "max_size" ) ) ) .add_property( "coef", make_getter( &Config::coef ), make_setter( &Config::coef ) ) .add_property( "path", make_getter( &Config::path ), make_setter( &Config::path ) ) .add_property( "max_size", make_getter( &Config::max_size ), make_setter( &Config::max_size ) ) .def( "__str__", Config_Str ) .def( "__repr__", Config_Repr ) .add_property( "as_dict", Config_ToDict, Config_FromDict ) ;

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

वर्ग आवरण को बनाने और कॉपी करने की क्षमता के बिना

तो सिंगलटन। इसे वर्तमान पहचानकर्ता को प्राप्त करने के लिए वर्तमान एप्लिकेशन के पूर्वोक्त कॉन्फ़िगरेशन पैरामीटर और कुछ प्रकार के जादू काउंटर शामिल होने दें।

 class Single { public: static int CurrentID(); static Config& AppConfig(); static void AppConfig( Config const& ); private: int mCurrentID; Config mAppConfig; Single(); Single( Single const& ); static Single& Instance(); int ThisCurrentID(); Config& ThisAppConfig(); void ThisAppConfig( Config const& ); };

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

 #include "single.h" #include <boost/thread.hpp> using boost::mutex; using boost::unique_lock; const double CONFIG_DEFAULT_COEF = 2.5; const int CONFIG_DEFAULT_MAX_SIZE = 0x1000; const string CONFIG_DEFAULT_PATH = "."; int Single::CurrentID() { return Instance().ThisCurrentID(); } Config& Single::AppConfig() { return Instance().ThisAppConfig(); } void Single::AppConfig( Config const& config ) { Instance().ThisAppConfig( config ); } Single::Single() : mCurrentID( 0 ) { mAppConfig.coef = CONFIG_DEFAULT_COEF; mAppConfig.max_size = CONFIG_DEFAULT_MAX_SIZE; mAppConfig.path = CONFIG_DEFAULT_PATH; } Single& Single::Instance() { static mutex single_mutex; unique_lock<mutex> single_lock( single_mutex ); static Single instance; return instance; } int Single::ThisCurrentID() { static mutex id_mutex; unique_lock<mutex> id_lock( id_mutex ); return ++mCurrentID; } Config& Single::ThisAppConfig() { return mAppConfig; } void Single::ThisAppConfig( Config const& config ) { mAppConfig = config; }

केवल तीन स्थिर तरीके हैं, रैपर को जटिल नहीं होना चाहिए, यदि आप एक को ध्यान में नहीं रखते हैं, लेकिन ... हालांकि, नहीं, बिल्कुल नहीं:
1. आप एक वर्ग का उदाहरण नहीं बना सकते
2. आप किसी वर्ग के उदाहरण की प्रतिलिपि नहीं बना सकते
3. हमने अभी तक स्थिर तरीकों को नहीं लपेटा है

  class_<Single, noncopyable>( "Single", no_init ) .def( "CurrentID", &Single::CurrentID ) .staticmethod( "CurrentID" ) .def( "AppConfig", static_cast< Config& (*)() >( &Single::AppConfig ), return_value_policy<reference_existing_object>() ) .def( "AppConfig", static_cast< void (*)( Config const& ) >( &Single::AppConfig ) ) .staticmethod( "AppConfig" ) ;

जैसा कि आप देख सकते हैं, 1 और 2 अंक से जुड़ी सभी कठिनाइयाँ टेम्पलेट पैरामीटर बूस्ट को निर्दिष्ट करने के लिए नीचे आती हैं :: गैर - परिवर्तनीय और पैरामीटर को बढ़ावा देने के लिए :: python :: no_init से टेम्पलेट क्लास कंस्ट्रक्टर को बढ़ावा देने के लिए :: python / class_।
यदि आप चाहते हैं कि क्लास कॉपी करने का समर्थन करे या एक डिफॉल्ट कंस्ट्रक्टर हो, तो आप रैपर क्लास प्रॉपर्टी जनरेटर के संबंधित साइलेंसर को मिटा सकते हैं।
सामान्यतया, डिफ़ॉल्ट कंस्ट्रक्टर को .def (init <> ()) से नीचे घोषित किया जा सकता है, कुछ तो अलग से वर्णित मापदंडों के साथ अन्य कंस्ट्रक्टरों के साथ सुसंगतता के लिए भी करते हैं, रैपर टेम्पलेट कंस्ट्रक्टर के लिए भी no_init पास करते हैं। एक रैपर क्लास की घोषणा करते समय, एक पैरामीटर के साथ डिफॉल्ट कंस्ट्रक्टर के साथ डिफॉल्ट कंस्ट्रक्टर को बदलने का विकल्प भी होता है, जैसा कि हमने पहले ही कॉन्फिगरेशन स्ट्रक्चर के लिए किया था।
तीसरे पैराग्राफ के साथ, सब कुछ सामान्य रूप से सरल है, यह घोषणा करके कि स्थैतिक विधि इस विधि के सभी अधिभार के रैपर () के माध्यम से घोषित करने के बाद .staticmethod () में शामिल है।
सामान्य तौर पर, बाकी लोग अब सवाल नहीं उठाते हैं और पहले भाग से हमें परिचित होते हैं, सिवाय एक मज़ेदार छोटी सी बात के लिए - वापसी की नीति_वाल्यू_पोलिश <संदर्भ_एक्सिस्टेंट_बॉज> मान संदर्भ द्वारा लौटाया जाता है, इसके बारे में और बाद में।

नीति "मुझे मत मारो, मैं एक अनुवादक हूँ"

हमारे सिंगलटन के तरीकों को लपेटने में सबसे बड़ी कठिनाई विधि से वस्तु संदर्भ की वापसी थी

  static Config& AppConfig();

बस इतना है कि पायथन इंटरप्रेटर का कचरा कलेक्टर (जीसी) विधि से संदर्भ द्वारा लौटाए गए वर्ग के क्षेत्र की सामग्री को नहीं हटाता है, हम रिटर्न_वल्यू_पोलिश <संदर्भ_existing_object> का उपयोग करते हैं।
Boost.Python का जादू इतना कठोर है कि जब आप Python कोड निष्पादित करते हैं, तो AppConfig () के परिणाम के क्षेत्रों को बदलने से सिंगलटन फ़ील्ड में परिवर्तन होगा जैसे कि C ++ में हो रहा था! पायथन कमांड लाइन पर निम्नलिखित कोड चलाकर:

 from example import * Single.AppConfig().coef = 123.45 Single.AppConfig()

हम निष्कर्ष निकालते हैं:

 Config: { coef: 123.45, path: '.', max_size: 4096 }

प्राप्त विधि के लिए एक नीति के साथ एक संपत्ति जोड़ें

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

  .add_static_property( "current_id", &Single::CurrentID ) .add_static_property( "app_config", make_function( static_cast< Config& (*)() >( &Single::AppConfig ), return_value_policy<reference_existing_object>() ), static_cast< void (*)( Config const& ) >( &Single::AppConfig ) )

एकल :: करंट विधि को एक या दो के लिए करंट_ड प्रॉपर्टी द्वारा लपेटा जाता है, लेकिन देखें कि एकल के दो अधिभार के लिए एक "सुंदर" आवरण क्या है: AppConfig, क्रमशः, प्राप्त करें और app_config संपत्ति के सेट-तरीके। और ध्यान दें कि हमें get_value_policy <reference_existing_object> रिटर्न वैल्यू पॉलिसी सेट करने के लिए विशेष मेक_फंक्शन फ़ंक्शन का उपयोग करने के लिए प्राप्त विधि का उपयोग करना था।
बहुत सावधान रहें, आप मेक_गेटर फ़ंक्शन का उपयोग तरीकों के लिए नहीं कर सकते हैं, इसका उपयोग केवल C ++ वर्ग फ़ील्ड के लिए किया जाता है, उन विधियों के लिए जिन्हें आपको फ़ंक्शन का उपयोग करने की आवश्यकता है। यदि आपको संपत्ति के तरीकों में से किसी एक तरीके में रिटर्न वैल्यू पॉलिसी सेट करने की आवश्यकता है, तो आपको मेक_फंक्शन का उपयोग करने की आवश्यकता है। अब आपके पास .def के रूप में return_value_policy के लिए एक सहायक अतिरिक्त तर्क नहीं है, इसलिए आपको एक बार में एक तर्क के साथ फ़ंक्शन और रिटर्न वैल्यू पॉलिसी को पास करना होगा।

नीति "यहां एक नई वस्तु है - इसे हटाएं"

इसलिए, हमने पहले ही पता लगा लिया है कि संदर्भ द्वारा लौटाए गए ऑब्जेक्ट को हटाने से अजगर जीसी को कैसे रोका जाए। हालांकि, कभी-कभी आपको भंडारण के लिए एक नई वस्तु को अजगर में स्थानांतरित करने की आवश्यकता होती है। आपके परिणाम ~~में पीड़ा के~~ अंतिम चर के ~~रूप में~~ जैसे ही जीसी ऑब्जेक्ट को सही ढंग से हटा देगा। इसके लिए एक return_value_policy <manage_new_object> पॉलिसी है।
आइए एक विधि प्राप्त करें जो एक नए ऑब्जेक्ट में कॉन्फ़िगरेशन पैरामीटर को क्लोन करता है। लपेटने के लिए एक विज्ञापन जोड़ें।

 Config* Single_CloneAppConfig();

और wra.cpp में हम इसके कार्यान्वयन को जोड़ते हैं:

 Config* Single_CloneAppConfig() { return new Config( Single::AppConfig() ); }

एक नई विधि के साथ manage_new_object नीति तदनुसार एकल वर्ग के आवरण में दिखाई देगी:

  .def( "CloneAppConfig", Single_CloneAppConfig, return_value_policy<manage_new_object>() )

यह सत्यापित करने के लिए कि कॉन्फ़िगरेशन आवश्यक होने पर वास्तव में हटा दिया गया है, पूरी तरह से गैर-सी-शैली कॉन्फ़िगरेशन संरचना में विध्वंसक घोषित करें। विध्वंसक में, हम बस स्टैड के माध्यम से STDOUT में आउटपुट करते हैं: हटाए गए कॉन्फ़िगर उदाहरण के क्षेत्रों को देखें:

 Config::~Config() { cout << "Config destructor of Config: { coef: " << coef << ", path: '" << path << "', max_size: " << max_size << " }" << endl; }

हम कोशिश करते हैं!
पायथन 3.x में परीक्षण स्क्रिप्ट में, हम कॉन्फिग को क्लोन करते हैं, उन्हें किसी भी तरह से संशोधित करते हैं और CloneAppConfig () के माध्यम से बनाई गई ऑब्जेक्ट के सभी लिंक रीसेट करते हैं:

 from example import * c = Single.CloneAppConfig() c.coef = 11.11; c.path = 'cloned'; c.max_size = 111111 print( "c.coef = 12.34; c.path = 'cloned'; c.max_size = 100500" ) print( "c:", c ); print( "Single.AppConfig():", Single.AppConfig() ) print( "c = Single.CloneAppConfig()" ); c = Single.CloneAppConfig() c.coef = 22.22; c.path = 'another'; c.max_size = 222222 print( "c.coef = 22.22; c.path = 'another'; c.max_size = 222222" ) print( "c:", c ); print( "Single.app_config:", Single.app_config ) print( "c = None" ); c = None print( "Single.app_config:", Single.app_config )

विनाशकों को ठीक उसी समय कहा जाता है जब यह अपेक्षित होता है, जब ऑब्जेक्ट का अंतिम लिंक गायब हो जाता है।
यहाँ प्रदर्शित किया जाना चाहिए:

 c.coef = 12.34; c.path = 'cloned'; c.max_size = 100500 c: { coef: 11.11, path: 'cloned', max_size: 111111 } Single.AppConfig(): { coef: 2.5, path: '.', max_size: 4096 } c = Single.CloneAppConfig() Config::~Config() destructor of object: { coef: 11.11, path: 'cloned', max_size: 111111 } c.coef = 22.22; c.path = 'another'; c.max_size = 222222 c: { coef: 22.22, path: 'another', max_size: 222222 } Single.app_config: { coef: 2.5, path: '.', max_size: 4096 } c = None Config::~Config() destructor of object: { coef: 22.22, path: 'another', max_size: 222222 } Single.app_config: { coef: 2.5, path: '.', max_size: 4096 } Config::~Config() destructor of object: { coef: 2.5, path: '.', max_size: 4096 }

होमवर्क के रूप में, कॉन्फ़िगरेशन रैपर में __del__ पद्धति को जोड़ने का प्रयास करें - पायथन में विध्वंसक का एक एनालॉग, आप देखेंगे कि रैपर और वे ऑब्जेक्ट जिनके लिए वे संदर्भित हैं, विपरीत हैं।

दूसरे भाग के निष्कर्ष में

इसलिए, हम संदर्भ द्वारा दो नई वापसी मूल्य नीतियों के साथ व्यवहार में परिचित हुए: reference_existing_object और manage_new_object । यही है, हमने सीखा है कि मौजूदा C ++ ऑब्जेक्ट के संदर्भ के रूप में रिटर्न वैल्यू के रैपर ऑब्जेक्ट का उपयोग कैसे किया जाए, और C ++ में बनाई गई GC Python नई ऑब्जेक्ट्स की देखभाल में भी स्थानांतरित किया जाए।
हमने संक्षेप में पता लगाया कि यदि C ++ में डिफ़ॉल्ट क्लास कंस्ट्रक्टर लगाए गए हैं तो कैसे कार्य करें। यह न केवल एक सिंगलटन या एक सार वर्ग के मामले में, बल्कि कई विशिष्ट वर्गों के लिए भी सच है, जिनमें से उदाहरण शायद आपकी आंखों के सामने हैं।
तीसरे भाग में, एक सरल एनम रैपर हमें इंतजार कर रहा है, हम C ++ से पायथन और इसके विपरीत बाइट सरणी के लिए अपना स्वयं का कनवर्टर लिखेंगे, और यह भी सीखेंगे कि उनके रैपर के स्तर पर C ++ वर्गों की विरासत का उपयोग कैसे करें।
अगला, हम C ++ से पायथन और इसके विपरीत अपवादों को परिवर्तित करने की जादुई दुनिया की प्रतीक्षा कर रहे हैं।
मेरे अनुमान लगाने के बाद क्या होगा, विषय एक गेंद की तरह घूमता है: इतना छोटा और कॉम्पैक्ट, जब तक आप इसे खोलना शुरू नहीं करते ...
2 भाग की परियोजना का लिंक यहां पाया जा सकता है । MSVS v11 प्रोजेक्ट, जिसे Python 3.3 x64 के साथ निर्मित करने के लिए कॉन्फ़िगर किया गया है।

उपयोगी लिंक

Boost.Python प्रलेखन
रैपर वर्ग को बढ़ावा देने के लिए निर्माता :: अजगर :: वर्ग_
Boost.Python में लिंक की गई नीतियां
विंडोज के लिए बूस्ट के साथ शुरुआत करना
* निक्स के लिए बूस्ट के साथ शुरुआत करना
Boost.Python विधानसभा की सूक्ष्मता

सी ++ और पायथन का संयोजन। बूस्ट.पाइथन की सूक्ष्मताएं। भाग दो