Boost.Python में रूपांतरण टाइप करें। हम सामान्य प्रकार के C ++ और पायथन के बीच रूपांतरण करते हैं

यह लेख C ++ API आवरण कहानी की निरंतरता नहीं है। आज कोई रैपर नहीं होगा। हालांकि तार्किक रूप से यह इस कहानी का तीसरा भाग है।
आज रक्त का एक समुद्र होगा, मौजूदा प्रकारों का विघटन और दूसरी भाषा में परिचित एनालॉग्स में उनके जादुई परिवर्तन।
हम लाइनों के बीच मौजूदा रूपांतरण के बारे में बात नहीं कर रहे हैं, नहीं, हम अपने स्वयं के कन्वर्टर्स लिखेंगे।
हम सामान्य पायथन डेटाइम लाइफटाइम लाइफटाइम को बढ़ावा में बदल देंगे :: पॉज़िक्स_टाइम :: बूस्ट लाइब्रेरी का समय और इसके विपरीत, इसके साथ नरक में, हम आम तौर पर पूरे डेटाइम लाइब्रेरी को बढ़ावा प्रकारों में बदल देते हैं! और इसलिए उबाऊ नहीं होने के लिए, हम अंतर्निहित पायथन 3.x बाइट सरणी वर्ग का त्याग करते हैं, इसके लिए अभी तक Boost.Python में कोई कनवर्टर नहीं है, और फिर हम नए पायथन कनवर्टर uuid.UUID को बढ़ावा देने के लिए बाइट सरणी रूपांतरण का उपयोग करते हैं :: uuids: : उूयड । हाँ, कनवर्टर में कनवर्टर का उपयोग किया जा सकता है!
खून के लिए तरस, कालीज़ीयम?!

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

• सी ++ और पायथन का संयोजन। बूस्ट.पाइथन की सूक्ष्मता। एक भाग
• सी ++ और पायथन का संयोजन। बूस्ट.पाइथन की सूक्ष्मता। भाग दो
• Boost.Python में रूपांतरण टाइप करें। हम सामान्य प्रकार के C ++ और पायथन के बीच रूपांतरण करते हैं
• C ++ और पायथन या राउंड ट्रिप के बीच अपवाद यात्रा

शुरू करने के बजाय

अगर किसी ने गौर नहीं किया है, तो Boost.Python एक बढ़िया काम करता है जो उचित प्रकार के पायथन क्लास ऑब्जेक्ट्स में स्केलरों का एक गुच्छा मोड़ता है। यदि आप तुलना करना चाहते हैं, तो शुद्ध सी में लिखें, सीधे सी-एपीआई का उपयोग करें, इसे अपने मस्तिष्क को पेश करने दें। आधुनिक प्रौद्योगिकी के आराम, एक आसान कुर्सी की सुविधा, गर्म स्नान की आवश्यकता और टीवी के लिए रिमोट कंट्रोल को समझने के लिए बहुत समय व्यतीत करें। लकड़ी के बेंच के प्रशंसक, छेद और छींटे में धोने, उन्हें लोकप्रिय कला में लगे रहने दें।
तो, इस तरह की एक चीज है: Boost.Python में अंतर्निहित कन्वर्टर्स - Python से C ++ और इसके विपरीत में बिल्ट-इन प्रकार के कन्वर्टर्स, जो कि आंशिक रूप से $ (BoostPath) \ libs \ _ython \ src \ कनवर्टर और $ (BoostPath) \ बूस्ट \ _ में बढ़ावा देते हैं। अजगर \ _ कनवर्टर। उनमें से कई हैं, वे लगभग 95% समस्याओं को हल करते हैं जब अंतर्निहित प्रकार के पायथन और सी ++ के साथ काम करते हैं, तो स्ट्रिंग रूपांतरण होता है, जो निश्चित रूप से आदर्श नहीं है , लेकिन अगर सी ++ में हम यूटीएफ -8 तार या चौड़ी-तारों के साथ काम करते हैं, तो सब कुछ तेज होगा। गुणात्मक और अभेद्य रूप से, उपयोग करने के लिए सुविधाजनक के अर्थ में।
लगभग सभी चीजें जो अंतर्निर्मित कन्वर्टर्स द्वारा नहीं की जाती हैं, आपकी कक्षाओं के रैपर द्वारा हल की जाती हैं। Boost.Python एक मेटा-भाषा के रूप में क्लास रैपर का वर्णन करने के लिए वास्तव में राक्षसी रूप से सरल तरीका प्रदान करता है जो कि पायथन क्लास की तरह दिखता है:

class_<Some>( "Some" ) .def( "method_A", &Some::method_A, args( "x", "y", "z" ) ) .def( "method_B", &Some::method_B, agrs( "u", "v" ) ) ; 

सब कुछ बहुत अच्छा है, लेकिन एक बात है ...
... एक बड़ा और अद्भुत एक: सी ++ और पायथन अपने स्वयं के पुस्तकालयों के साथ भाषाएं हैं। सी ++ में

 #include <boost/date_time.hpp> #include <boost/uuid/uuid.hpp> 

पायथन में वास्तविक तथ्य है:

 import datetime import uuid 

तो, आपके C ++ कोड में बहुत सी चीजें पहले से ही विशेष रूप से काम करने के लिए बंधी हो सकती हैं, उदाहरण के लिए, बढ़ावा :: gregorian :: date class, और Python में, बदले में, बहुत कुछ datetime.date वर्ग, इसके एनालॉग से बंधा हुआ है। पाइथन को बढ़ावा देने के आवरण के साथ काम करने के लिए :: gregorian :: दिनांक वर्ग सभी तरीकों के साथ लिपटे हुए, ओवरलोडिंग ऑपरेटरों और सामान्य डेटाटाइम के बजाय इसके उदाहरणों को छड़ी करने की कोशिश कर रहा है - मुझे यह भी पता नहीं है कि इसे क्या कहा जाता है, यह एक बैसाखी नहीं है, यह एक ग्रेनेड के साथ नृत्य कर रहा है। और यह ग्रेनेड विस्फोट करेगा, जूरी के सज्जनों। अजगर पक्ष पर, आपको तिथि और समय के अंतर्निहित पुस्तकालय के साथ काम करने की आवश्यकता है।
यदि आप इसे पढ़ते हैं, और अपने कोड को देखते हैं, जहां अर्क के माध्यम से आपको C ++ में पायथन डेटटाइम के क्षेत्र मिलते हैं, तो मुस्कुराने के लिए कुछ भी मूर्खतापूर्ण नहीं है, ऊपर दिए गए पैराग्राफ में वर्णित सब कुछ आपके लिए लागू नहीं होता है। यहां तक ​​कि अगर आपके पास C ++ में अपनी स्वयं की मेगा-क्लास तिथि / समय है, तो एक प्रकार के कनवर्टर को लिखने से बेहतर है कि उन्हें किसी तरह की साइकिल पद्धति में एक क्षेत्र को अनहुक किया जाए।
सामान्य तौर पर, यदि पायथन अपने स्वयं के प्रकार पर, और सी ++ पक्ष में अपने स्वयं के स्थापित प्रकार जो एक समान कार्यात्मक घटक के साथ मूल तर्क को लागू करता है, तो आपको एक कनवर्टर की आवश्यकता होती है।
आपको वास्तव में एक कनवर्टर की आवश्यकता है।

एक कनवर्टर क्या है

एक कन्वर्टर Boost.Python से C ++ प्रकार से पायथन टाइप या इसके विपरीत में पंजीकृत रूपांतरण है। C ++ की तरफ, आप परिचित प्रकारों का उपयोग करते हैं, पूर्ण विश्वास में कि पायथन में यह इसी प्रकार का होगा। असल में, कन्वर्टर्स आमतौर पर दोनों दिशाओं में लिखते हैं, लेकिन C ++ से पायथन में रूपांतरण लिखना आसान परिमाण का एक क्रम है, आप अपने लिए देखेंगे। बात यह है कि C ++ में एक उदाहरण बनाने के लिए मेमोरी की आवश्यकता होती है, जो अक्सर एक गैर-तुच्छ कार्य है। पाइथन में एक ऑब्जेक्ट बनाना एक बहुत ही सरल कार्य है, तो आइए C ++ से पाइथन में परिवर्तित करके शुरू करें।

C ++ से पायथन में रूपांतरण टाइप करें

C ++ से Python में बदलने के लिए, आपको एक ऐसी संरचना की आवश्यकता होती है जिसमें एक स्थिर रूपांतरण विधि हो, जो C ++ में एक प्रकार के संदर्भ को स्वीकार करता है और PyObject * को लौटाता है, Python C-API में उपयोग की जाने वाली किसी भी वस्तु के लिए एक सामान्य प्रकार और बढ़ावा देने के लिए :: python :: वस्तु।
आइए एक टेम्पलेट संरचना अभी प्राप्त करें क्योंकि हम एक सामूहिक वध चाहते हैं:

 template< typename T > struct type_into_python { static PyObject* convert( T const& ); }; 

उदाहरण के लिए, उदाहरण के प्रकार: posix_time :: ptime, टेम्पलेट संरचना विशेषज्ञता विधि: सभी को लागू करने की आवश्यकता है

 template<> PyObject* type_into_python<ptime>::convert( ptime const& ); 

और BOOST_PYTHON_MODULE के अंदर मॉड्यूल की घोषणा करते समय कनवर्टर को पंजीकृत करें:

  to_python_converter< ptime, type_into_python<ptime> >(); 

खैर, जब से मैंने अज़ कहा, आइए आपको और बुकी को बताता हूं। बढ़ावा देने के लिए कनवर्टर कार्यान्वयन :: posix_time :: ptime कुछ इस तरह दिखेगा:

 PyObject* type_into_python<ptime>::convert( ptime const& t ) { auto d = t.date(); auto tod = t.time_of_day(); auto usec = tod.total_microseconds() % 1000000; return PyDateTime_FromDateAndTime( d.year(), d.month(), d.day(), tod.hours(), tod.minutes(), tod.seconds(), usec ); } 

महत्वपूर्ण! मॉड्यूल पंजीकृत करते समय, हमें निश्चित रूप से सी-एपीआई के माध्यम से डेटाइम कनेक्ट करने की आवश्यकता है:

  PyDateTime_IMPORT; to_python_converter< ptime, type_into_python<ptime> >(); 

स्ट्रिंग PyDateTime_IMPORT के बिना , कुछ भी बंद नहीं होगा।

हम सामान्य रूप से भाग्यशाली थे कि पायथन सी-एपीआई के पास अपने मापदंडों द्वारा एक नए डेटाटाइम.टाइमटाइम पर PyObject * बनाने के लिए तैयार कार्य है, जो अनिवार्य रूप से डेटाटाइम वर्ग के निर्माता का एक एनालॉग है। और बिना किसी भाग्य के, बूस्ट के पास ऐसी "मज़ेदार" एपीआई है जो पीटाइम क्लास के लिए है। कक्षा पूरी तरह से स्वतंत्र नहीं हुई, आपको उसमें से तारीख और समय निकालना होगा, जो कि वहां के अलग-अलग घटक हैं, और समय time_duration के रूप में प्रस्तुत किया जाता है - एक एनालॉग इतना डेटाइम.टाइम नहीं, बल्कि डेटाइम टाइमस्टेमेल्टा ! यह, सामान्य तौर पर, C ++ में डेटाइम लाइब्रेरी के प्रकारों का प्रतिनिधित्व करने की अनुमति नहीं देगा, लेकिन यह काफी अप्रिय है जो बढ़ावा देता है :: posix_time :: time_duration माइक्रोसेकंड और मिलीसेकंड तक सीधे पहुंच प्रदान नहीं करता है। इसके बजाय, आपको या तो "cunningly" कार्य के लिए fractional_seconds () विधि के साथ काम करना होगा, या मूर्खतापूर्ण रूप से डरावने काम करना होगा - मॉड्यूल Total_microseconds ()% 1000000 ले लो। इससे भी बदतर - मैंने अभी तक फैसला नहीं किया है, मैं नहीं जानता कि कैसे time_duration बनाया जाता है। हम इसके लिए डेटटाइम.टाइम क्लास को बाहर कर देंगे, और हम अभी के लिए इसी तरह के अन्य डेटाइमटाइमडिमेलेटा क्लास को नहीं छूएंगे।

अजगर से C ++ में परिवर्तित करें

हे, मेरे दोस्तों, यह वास्तव में एक कठिन बिंदु है। स्टॉक वैलिडोल, अपनी सीट बेल्ट जकड़ें।
सब कुछ बिल्कुल एक जैसा लगता है: हम एक संरचना टेम्पलेट बनाते हैं जिसमें दो विधियाँ परिवर्तनीय और निर्माण - कन्वर्ट करने की क्षमता और C ++ में कंस्ट्रक्टर टाइप करती हैं। दरअसल, यह वही है जो तरीकों को कहा जाता है, मुख्य बात यह है कि पंजीकरण के दौरान उन्हें संदर्भित करना है, यह हमारे टेम्पलेट संरचना के निर्माता में ऐसा करने के लिए सबसे सुविधाजनक है:

 template< typename T > struct type_from_python { type_from_python() { converter::registry::push_back( convertible, construct, type_id<T>() ); } static void* convertible( PyObject* ); static void construct( PyObject*, converter::rvalue_from_python_stage1_data* ); }; 

दरअसल, मॉड्यूल की घोषणा करते समय, इस संरचना के निर्माता को कॉल करने के लिए पर्याप्त होगा। ठीक है, निश्चित रूप से, आपको प्रत्येक परिवर्तनीय प्रकार के लिए इन तरीकों को लागू करने की आवश्यकता है, उदाहरण के लिए, समय के लिए:

 template<> void* type_from_python<ptime>::convertible( PyObject* ); template<> void type_from_python<ptime>::construct( PyObject*, converter::rvalue_from_python_stage1_data* ); 

आइए, परिवर्तनीयता परीक्षण पद्धति के कार्यान्वयन पर एक नज़र डालें और तुरंत निर्माण विधि:

 void* type_from_python<ptime>::convertible( PyObject* obj ) { return PyDateTime_Check( obj ) ? obj : nullptr; } void type_from_python<ptime>::construct( PyObject* obj, converter::rvalue_from_python_stage1_data* data ) { auto storage = reinterpret_cast< converter::rvalue_from_python_storage<ptime>* >( data )->storage.bytes; date date_only( PyDateTime_GET_YEAR( obj ), PyDateTime_GET_MONTH( obj ), PyDateTime_GET_DAY( obj ) ); time_duration time_of_day( PyDateTime_DATE_GET_HOUR( obj ), PyDateTime_DATE_GET_MINUTE( obj ), PyDateTime_DATE_GET_SECOND( obj ) ); time_of_day += microsec( PyDateTime_DATE_GET_MICROSECOND( obj ) ); new(storage) ptime( date_only, time_of_day ); data->convertible = storage; } 

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

  new(storage) ptime( date_only, time_of_day ); 

यह मेजबान नया है। यह आपके नए ऑब्जेक्ट को निर्दिष्ट स्थान पर बनाता है। यह वह स्थान है जिसे हमें अभी भी गणना करने की आवश्यकता है, हमें वांछित सूचक प्राप्त करने के लिए निम्नलिखित तरीके की पेशकश की जाती है:

  auto storage = reinterpret_cast< converter::rvalue_from_python_storage<ptime>* >( data )->storage.bytes; 

मैं इस पर कोई टिप्पणी नहीं करूंगा। जरा याद करो।
गैर-स्व-निहित पीटाइम वर्ग के समझने योग्य निर्माता को आमंत्रित करने के लिए बाकी सब कुछ अतिरिक्त गणना है।
किसी अन्य फ़ील्ड को अंत में भरना न भूलें:

  data->convertible = storage; 

फिर से, मुझे नहीं पता कि इसे नरम कैसे कहा जाए, बस याद रखें कि यह महत्वपूर्ण है और फ़ील्ड को भरना होगा। इसे सार्वभौमिक खुशी के सामने एक अप्रिय छोटी चीज के रूप में सोचें।
यह किसी और के द्वारा कैसे किया जाता है , इसके उदाहरण यहाँ , FAQ खंड में Boost.Python वेबसाइट पर यहाँ और यहाँ देखे जा सकते हैं।

डेटाइम प्रकारों को <बढ़ावा / date_time.hpp> और इसके विपरीत में परिवर्तित करना

कुल, तिथि और समय के लिए अलग-अलग, सब कुछ काफी सरल है। हमारी टेम्प्लेट संरचना के लिए धन्यवाद, हमें केवल अपने टेम्प्लेट संरचनाओं को विशेषज्ञता के लिए निम्न विधियों की तारीख और समय_ के लिए एक कार्यान्वयन जोड़ना होगा:

 template<> PyObject* type_into_python<date>::convert( date const& ); template<> void* type_from_python<date>::convertible( PyObject* ); template<> void type_from_python<date>::construct( PyObject*, converter::rvalue_from_python_stage1_data* ); template<> PyObject* type_into_python<time_duration>::convert( time_duration const& ); template<> void* type_from_python<time_duration>::convertible( PyObject* ); template<> void type_from_python<time_duration>::construct( PyObject*, converter::rvalue_from_python_stage1_data* ); 

कार्य सरल है, यह पिछली विधियों को दिनांक और समय के लिए जोड़े में अलग-अलग तोड़ने के लिए उबलता है।
बढ़ावा देने के लिए :: gregorian :: दिनांक और datetime.date :

 PyObject* type_into_python<date>::convert( date const& d ) { return PyDate_FromDate( d.year(), d.month(), d.day() ); } void* type_from_python<date>::convertible( PyObject* obj ) { return PyDate_Check( obj ) ? obj : nullptr; } void type_from_python<date>::construct( PyObject* obj, converter::rvalue_from_python_stage1_data* data ) { auto storage = reinterpret_cast< converter::rvalue_from_python_storage<date>* >( data )->storage.bytes; new(storage) date( PyDateTime_GET_YEAR( obj ), PyDateTime_GET_MONTH( obj ), PyDateTime_GET_DAY( obj ) ); data->convertible = storage; } 

और बढ़ावा देने के लिए :: posix_time :: time_duration और datetime.time :

 PyObject* type_into_python<time_duration>::convert( time_duration const& t ) { auto usec = t.total_microseconds() % 1000000; return PyTime_FromTime( t.hours(), t.minutes(), t.seconds(), usec ); } void* type_from_python<time_duration>::convertible( PyObject* obj ) { return PyTime_Check( obj ) ? obj : nullptr; } void type_from_python<time_duration>::construct( PyObject* obj, converter::rvalue_from_python_stage1_data* data ) { auto storage = reinterpret_cast< converter::rvalue_from_python_storage<time_duration>* >( data )->storage.bytes; time_duration* t = new(storage) time_duration( PyDateTime_TIME_GET_HOUR( obj ), PyDateTime_TIME_GET_MINUTE( obj ), PyDateTime_TIME_GET_SECOND( obj ) ); *t += microsec( PyDateTime_TIME_GET_MICROSECOND( obj ) ); data->convertible = storage; } 

हमारे मॉड्यूल में यह सब सामान रजिस्टर करना कुछ इस तरह होगा:

 BOOST_PYTHON_MODULE( ... ) { ... PyDateTime_IMPORT; to_python_converter< ptime, type_into_python<ptime> >(); type_from_python< ptime >(); to_python_converter< date, type_into_python<date> >(); type_from_python< date >(); to_python_converter< time_duration, type_into_python<time_duration> >(); type_from_python< time_duration >(); ... } 

हम दिनांक और समय को परिवर्तित करने के साथ काम की जांच करते हैं

कार्रवाई में हमारे मेगा-रूपांतरण की जांच करने का समय है, हमें सभी प्रकार के अनावश्यक कार्य मिलेंगे जो इनपुट पर एक तारीख / समय को स्वीकार करते हैं और आउटपुट पर दिनांक / समय वापस करते हैं।

 ptime tomorrow(); ptime day_before( ptime const& the_moment ); date last_day_of_this_month(); date year_after( date const& the_day ); time_duration delta_between( ptime const& at, ptime const& to ); time_duration plus_midday( time_duration const& the_moment ); 

अजगर से कॉल करने के लिए उन्हें हमारे मॉड्यूल में घोषित करें:

  def( "tomorrow", tomorrow ); def( "day_before", day_before, args( "moment" ) ); def( "last_day_of_this_month", last_day_of_this_month ); def( "year_after", year_after, args( "day" ) ); def( "delta_between", delta_between, args( "at", "to" ) ); def( "plus_midday", plus_midday, args( "moment" ) ); 

जिस तरह से हमारे कार्य निम्नलिखित हैं (हालांकि वास्तव में यह महत्वपूर्ण नहीं है, इनपुट / आउटपुट प्रकार महत्वपूर्ण हैं):

 ptime tomorrow() { return microsec_clock::local_time() + days( 1 ); } ptime day_before( ptime const& that ) { return that - days( 1 ); } date last_day_of_this_month() { date today = day_clock::local_day(); date next_first_day = (today.month() == Dec) ? date( today.year() + 1, 1, 1 ) : date( today.year(), today.month() + 1, 1 ); return next_first_day - days( 1 ); } date year_after( date const& the_day ) { return the_day + years( 1 ); } time_duration delta_between( ptime const& at, ptime const& to ) { return to - at; } time_duration plus_midday( time_duration const& the_moment ) { return time_duration( 12, 0, 0 ) + the_moment; } 

विशेष रूप से, इस तरह की एक सरल स्क्रिप्ट है (पायथन 3.x में):

 from someconv import * from datetime import * # test datetime.datetime <=> boost::posix_time::ptime t = tomorrow(); print( 'Tomorrow at same time:', t ) for _ in range(3): t = day_before(t); print( 'Day before that moment:', t ) # test datetime.date <=> boost::gregorian::date d = last_day_of_this_month(); print( 'Last day of this month:', d ) for _ in range(3): d = year_after(d); print( 'Day before that day:', d ) # test datetime.time <=> boost::posix_time::time_duration at = datetime.now() to = at + timedelta( seconds=12*60*60 ) dt = delta_between( at, to ) print( "Delta between '{at}' and '{to}' is '{dt}'".format( at=at, to=to, dt=dt ) ) t0 = time( 6, 30, 0 ) t1 = plus_midday( t0 ) print( t0, "plus midday is:", t1 ) 

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

C ++ में बाइट वेक्टर के रूप में एक बाइट सरणी

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

नीचे दिया गया उदाहरण विशुद्ध रूप से अकादमिक है, यदि आपको कहीं मैनिक कोड ऑप्टिमाइज़ेशन की आवश्यकता है, और यही कारण है कि आप C ++ में मॉड्यूल कोड का हिस्सा लिखते हैं। यदि आप प्रदर्शन के पक्ष में हैं, तो आप सुरक्षित रूप से इस परिवर्तन का उपयोग कर सकते हैं।
पायथन 2.x के लिए, यह खंड सिद्धांत रूप में अप्रासंगिक है। तब बाइट सरणियों को स्ट्रिंग्स कहा जाता था। यूनिकोड के साथ काम करने और इसे मानक सी ++ लाइन में परिवर्तित करने के बारे में पियविक में यहां पढ़ना बहुत दिलचस्प होगा ।
लेकिन पायथन 3.x के लिए, यह रूपांतरण सामान्य वेक्टर का उपयोग करने के लिए सी-एपीआई के एक समूह के साथ कोड के एक विशाल टुकड़े को कम कर देगा ( बाइट एक अहस्ताक्षरित 8-बिट पूर्णांक - uint8_t ) है।

इसलिए, फिर से हम अपनी अद्भुत टेम्पलेट संरचनाओं और आनन्द का उपयोग करते हैं:

 typedef uint8_t byte; typedef vector<byte> byte_array; ... template<> PyObject* type_into_python<byte_array>::convert( byte_array const& ); template<> void* type_from_python<byte_array>::convertible( PyObject* ); template<> void type_from_python<byte_array>::construct( PyObject*, converter::rvalue_from_python_stage1_data* ); 

सभी समान, हम अपने मॉड्यूल की घोषणा में कन्वर्टर्स के पंजीकरण को जोड़ते हैं:

 BOOST_PYTHON_MODULE( ... ) { ... to_python_converter< byte_array, type_into_python<byte_array> >(); type_from_python< byte_array >(); } 

और सबसे सरल कार्यान्वयन, हम सिर्फ PyBytes ऑब्जेक्ट के C-API ज्ञान का उपयोग करते हैं और std के साथ काम करते हैं :: वेक्टर तरीके:

 PyObject* type_into_python<byte_array>::convert( byte_array const& ba ) { const char* src = ba.empty() ? "" : reinterpret_cast<const char*>( &ba.front() ); return PyBytes_FromStringAndSize( src, ba.size() ); } void* type_from_python<byte_array>::convertible( PyObject* obj ) { return PyBytes_Check( obj ) ? obj : nullptr; } void type_from_python<byte_array>::construct( PyObject* obj, converter::rvalue_from_python_stage1_data* data ) { auto storage = reinterpret_cast< converter::rvalue_from_python_storage<byte_array>* >( data )->storage.bytes; byte* dest; Py_ssize_t len; PyBytes_AsStringAndSize( obj, reinterpret_cast<char**>( &dest ), &len ); new(storage) byte_array( dest, dest + len ); data->convertible = storage; } 

यह संभावना नहीं है कि अतिरिक्त टिप्पणियों की आवश्यकता होगी, PyBytes ऑब्जेक्ट के सी-एपीआई के ज्ञान के लिए, मैं इसे यहां भेजूंगा।

Uuid.UUID को बढ़ावा देने के लिए कनवर्ट करें :: uuids :: uuid और इसके विपरीत

आप हँसेंगे, लेकिन इससे पहले हमने शुरुआत में ही उन दो टेम्प्लेटों को बनाकर अपना काम आसान कर दिया था, जो फिर से तीन तरीकों के कार्यान्वयन के लिए आते हैं:

 using namespace boost::uuids; ... template<> PyObject* type_into_python<uuid>::convert( uuid const& ); template<> void* type_from_python<uuid>::convertible( PyObject* ); template<> void type_from_python<uuid>::construct( PyObject*, converter::rvalue_from_python_stage1_data* ); 

हम मॉड्यूल घोषणा में दो नई लाइनें जोड़ते हैं - वहाँ और पीछे रूपांतरण का पंजीकरण:

  to_python_converter< uuid, type_into_python<uuid> >(); type_from_python< uuid >(); 

और अब सबसे दिलचस्प बात यह है कि सी-एपीआई हमें यहां मदद नहीं करेगा, यह बाधा बनने की अधिक संभावना है, इसे बढ़ावा देने के माध्यम से कार्य करना आसान है :: अजगर :: पायथन मॉड्यूल "यूआईडी" और उसी मॉड्यूल के वर्ग "यूयूआईडी" का आयात करें।

 static object py_uuid = import( "uuid" ); static object py_uuid_UUID = py_uuid.attr( "UUID" ); PyObject* type_into_python<uuid>::convert( uuid const& u ) { return incref( py_uuid_UUID( object(), byte_array( u.data, u.data + sizeof(u.data) ) ).ptr() ); } void* type_from_python<uuid>::convertible( PyObject* obj ) { return PyObject_IsInstance( obj, py_uuid_UUID.ptr() ) ? obj : nullptr; } void type_from_python<uuid>::construct( PyObject* obj, converter::rvalue_from_python_stage1_data* data ) { auto storage = reinterpret_cast< converter::rvalue_from_python_storage<uuid>* >( data )->storage.bytes; byte_array ba = extract<byte_array>( object( handle<>( borrowed( obj ) ) ).attr( "bytes" ) ); uuid* res = new(storage) uuid; memcpy( res->data, &ba.front(), ba.size() ); data->convertible = storage; } 

वैश्विक चर का उपयोग करने के लिए क्षमा करें, यह आमतौर पर निर्माता और विध्वंसक में क्रमशः Py_Initialize () और Py_Finalize () के साथ एक सिंगलटन में किया जाता है। लेकिन यहाँ हमारे पास एक विशुद्ध शैक्षिक उदाहरण है और इसका उपयोग केवल पायथन से ही किया जाता है, आप इस तरह के त्वरित दृष्टिकोण से प्राप्त कर सकते हैं, एक बार फिर मुझे खेद है, लेकिन कोड अधिक स्पष्ट है।

चूंकि इन विधियों में व्यवहार उपरोक्त सभी से बहुत अलग है, इसलिए अधिक विस्तार से वर्णन करना आवश्यक है कि वास्तव में क्या हो रहा है।
Py_uuid में, हमने पायथन मानक पुस्तकालय से uuid प्लग-इन ऑब्जेक्ट को सहेजा है।
Py_uuid_UUID में हमने क्लास uuid.UUID का ऑब्जेक्ट सेव किया। यह स्वयं वर्ग है। इस ऑब्जेक्ट पर ब्रैकेट्स लगाने से कंस्ट्रक्टर को कॉल आएगा और इस प्रकार का ऑब्जेक्ट बन जाएगा। बाद में हम क्या करेंगे। हालाँकि, यह वर्ग अपने आप में अभी भी परिवर्तनीय विधि के लिए उपयोगी है - इस तर्क के प्रकार की जाँच करना कि क्या वस्तु एक UUID है।

पायथन से, C ++ से सब कुछ स्पष्ट है - बस कंस्ट्रक्टर को कॉल करें, कोई भी पहले पैरामीटर ( डिफ़ॉल्ट कंस्ट्रक्टर को बढ़ावा देने वाला :: python :: ऑब्जेक्ट सिर्फ कोई भी नहीं बनाएगा ) पास करें, और दूसरा पिछले अनुभाग से हमारे बाइट सरणी को छोड़ देता है। यदि आपके पास पायथन 2.x है, तो कोड थोड़ा बदल जाता है और सरल हो जाता है, बस स्ट्रिंग पास करें और दिखावा करें कि यह एक बाइट सरणी है।

जब परिवर्तनीयता के लिए पायथन ऑब्जेक्ट की जाँच करते हैं, तो PyObject_IsInstance () फ़ंक्शन हमें बहुत मदद करता है।
हम Pyrbject * के पॉइंटर को टाइप करते हैं uuid.UUID का उपयोग करके ptr () को बढ़ावा देने का तरीका :: python :: object। यह वह जगह है जहाँ वर्ग वस्तु स्वयं काम में आई। वास्तव में, पायथन में कक्षाएं समान वस्तुएं हैं। और वह महान है। ऐसी तार्किक और बोधगम्य भाषा के लिए धन्यवाद।

यहां पाइथन से C ++ में रूपांतरण कोड दिया गया है, इस रेखा पर कुछ भी स्पष्ट नहीं है:

  byte_array ba = extract<byte_array>( object( handle<>( borrowed( obj ) ) ).attr( "bytes" ) ); 

यहां, वास्तव में, सब कुछ बेहद सरल है। PyObject * के रूप में आए uuid.UUID ऑब्जेक्ट से हम एक पूर्ण बढ़ावा :: python :: ऑब्जेक्ट बनाते हैं। संभाल के निर्माण पर ध्यान दें <> ( उधार (obj)) - यहाँ यह बहुत महत्वपूर्ण है कि उधार की गई कॉल को न खोएं, अन्यथा हमारी ताज़ा वस्तु विध्वंसक में पारित वस्तु को क्रैश कर देगी।
इसलिए, हमें uuid.UUID के एक तर्क के संदर्भ में Pythbject * से python :: ऑब्जेक्ट को बढ़ावा मिला। हम अपनी वस्तु से बाइट्स विशेषता लेते हैं, इसे निकालने के माध्यम से बाइट_अरे को बाहर निकालते हैं। सब कुछ, हमारे पास सामग्री है।
जो लोग क्रमबद्धता-deserialization के माध्यम से सब कुछ करना पसंद करते हैं वे एक स्ट्रिंग में रूपांतरण के माध्यम से शौच कर सकते हैं और इसके विपरीत। किसी भी lexical_cast () उन्हें और गर्दन पर एक पत्थर की मदद करने के लिए। याद रखें कि C ++ में स्ट्रिंग्स बनाना और सीरियल करना अनिवार्य रूप से एक बहुत महंगा ऑपरेशन है।
पायथन 2.x उपयोगकर्ता तुरंत स्ट्रिंग के रूप में बाइट प्राप्त करेंगे। इस तरह की लाइनें, सी / सी ++ की तरह हुआ करती थीं, अनिवार्य रूप से चार * के जरिए।
सामान्य तौर पर, फिर सब कुछ सरल होता है, सरणी भरें, मुझे असुरक्षित नकल के लिए क्षमा करें, और पूरी की हुई वस्तु वापस C ++ में पास करें।

बाइट सरणी और यूयूआईडी रूपांतरणों के संचालन की जांच करें

आइए कुछ और कार्य करें जो C ++ और पायथन के बीच हमारे प्रकारों को आगे और पीछे चलाते हैं:

 byte_array string_to_bytes( string const& src ); string bytes_to_string( byte_array const& src ); uuid random_uuid(); byte_array uuid_bytes( uuid const& src ); 

हम उन्हें पायथन से कॉल करने के लिए अपने मॉड्यूल में वर्णन करेंगे:

 BOOST_PYTHON_MODULE( someconv ) { ... def( "string_to_bytes", string_to_bytes, args( "src" ) ); def( "bytes_to_string", bytes_to_string, args( "src" ) ); def( "random_uuid", random_uuid ); def( "uuid_bytes", uuid_bytes, args( "src" ) ); ... } 

वास्तव में उनका व्यवहार इतना महत्वपूर्ण नहीं है, तथापि, आइए ईमानदारी से उनके कार्यान्वयन को परिणाम की स्पष्टता के बारे में बताएं:

 byte_array string_to_bytes( std::string const& src ) { return byte_array( src.begin(), src.end() ); } string bytes_to_string( byte_array const& src ) { return string( src.begin(), src.end() ); } uuid random_uuid() { static random_generator gen_uuid; return gen_uuid(); } byte_array uuid_bytes( uuid const& src ) { return byte_array( src.data, src.data + sizeof(src.data) ); } 

सामान्य तौर पर, ऐसी परीक्षण स्क्रिप्ट (पायथन 3.x में):

 from someconv import * from uuid import * ... # test bytes <=> std::vector<uint8_t> print( bytes_to_string( b"I_must_be_string" ) ) print( string_to_bytes( "I_must_be_byte_array" ) ) print( bytes_to_string( " - !".encode() ) ) print( string_to_bytes( " - !" ).decode() ) print( bytes_to_string( string_to_bytes( " -  !" ) ) ) # test uuid.UUID <=> boost::uuids::uuid u = random_uuid() print( 'Generated UUID (C++ module):', uuid_bytes(u) ) print( 'Generated UUID (in Python): ', u.bytes) 

इसे सही ढंग से काम करना चाहिए और परिणाम कुछ इस तरह देना चाहिए:

 I_must_be_string b'I_must_be_byte_array' - ! - ! -  ! Generated UUID (C++ module): b'\xf1B\xdb\xa9<lL\x9d\x9a\xfd\xf3\xe9\x9f\xa6\x9aT' Generated UUID (in Python): b'\xf1B\xdb\xa9<lL\x9d\x9a\xfd\xf3\xe9\x9f\xa6\x9aT' 

वैसे, यदि आप सत्यापन के लिए पाइथन से UUID के कवर से C ++ तक उधार लेते हैं और हटाते हैं, तो आप अंतिम पंक्ति में ठीक से गिर जाएंगे, क्योंकि ऑब्जेक्ट पहले ही नष्ट हो जाएगा और बाइट्स से लेने के लिए कुछ भी नहीं होगा।

कुल मिलाकर

हमने न केवल कन्वर्टर्स लिखना, बल्कि उन्हें सामान्य बनाना, उन्हें लिखते समय श्रम लागत को कम करना और दूसरे में से एक का उपयोग करना सीखा। असल में, हम पहले से ही जानते हैं कि यह क्या है, इसका उपयोग कैसे करें और जहां यह आवश्यक है।
परियोजना का लिंक यहां है (~ 207 KB) । MSVS v11 प्रोजेक्ट, जिसे Python 3.3 x64 के साथ निर्मित करने के लिए कॉन्फ़िगर किया गया है।

उपयोगी लिंक

Boost.Python प्रलेखन
कैसे एक स्ट्रिंग कनवर्टर लिखने के लिए
कन्वर्ट यूनिकोड को अजगर 2.x
C ++ और पायथन के बीच सरणियों को बदलना
दिनांक / समय परिवर्तित करने का एक अन्य विकल्प