🈲 🦐 🤴 नई वास्तविकताओं के लिए पुराना कोड पैना करें 👨🏽 ⚽️ ☦️

इस लेख में मैं उन तरीकों में से एक के बारे में बात करूँगा जो C # C ++ प्रोग्राम कोड को C # में लिखे कोड में बदलने के लिए कम से कम प्रयास की अनुमति देता है। हालांकि, ये सिद्धांत भाषाओं के अन्य जोड़े के लिए उपयुक्त हैं। मैं तुरंत एक आरक्षण करना चाहता हूं कि विधि कोड को बदलने के लिए डिज़ाइन नहीं की गई है जो जीयूआई को लागू करती है।

ऐसा क्यों? उदाहरण के लिए, मैंने इस प्रकार प्रसिद्ध ग्राफिक लाइब्रेरी LibTiff (और एक ही समय में LibJpeg) को C # में पोर्ट किया। इसने मुझे उन कई लोगों के अनुभव का उपयोग करने की अनुमति दी, जिन्होंने .NET फ्रेमवर्क क्लास लाइब्रेरी के साथ-साथ मेरे कार्यक्रम में LibTiff बनाया था। लेख में कोड उदाहरण मुख्य रूप से LibTiff और LibJpeg से होंगे।

1. अवसंरचना

क्या आवश्यक है:

मूल कोड जिसे आप "एक क्लिक में" एकत्र कर सकते हैं।
परीक्षणों का एक सेट, जिसे "एक क्लिक में" भी किया जा सकता है।
संस्करण नियंत्रण प्रणाली।
Refactoring की मूल अवधारणा।

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

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

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

उदाहरण के लिए, LibTiff का उपयोग करने के लिए

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

Refactoring के बारे में, बस एक किताब पढ़ें। यह मार्टिन फाउलर की पुस्तक रिफैक्टिंग है। मौजूदा कोड में सुधार करना। " यदि आप इसे नहीं पढ़ते हैं, तो इसे अवश्य पढ़ें - किसी भी प्रोग्रामर के लिए, रिफैक्टिंग के सिद्धांतों का ज्ञान केवल उपयोगी है। पूरी पुस्तक को पढ़ने की आवश्यकता नहीं है। यह शुरुआत से लगभग 130 पृष्ठों को पढ़ने के लिए पर्याप्त है। खंड "एंबेडिंग ए मेथड" से पहले ये पहले पांच भाग और छठे भाग की शुरुआत हैं।

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

2. स्थानांतरण प्रक्रिया

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

स्थानांतरण प्रक्रिया को तीन बड़े चरणों में विभाजित किया जा सकता है:

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

इन सभी बिंदुओं को पूरा करने के बाद ही कोड की गति और सुंदरता को याद रखना लायक है।

मुख्य कठिनाई पहली अवस्था है। इस स्तर पर, आपको C / C ++ कोड को "शुद्ध C ++" में कोड में बदलना होगा, जो C # के सिंटैक्स के जितना करीब हो सके। इस स्तर पर, आपको इससे छुटकारा पाने की आवश्यकता है:

प्रीप्रोसेसर निर्देश
गोटो बयान
टाइप्डिफ बयान
सूचक अंकगणित
समारोह संकेत
कई विरासत
"मुफ्त" फ़ंक्शंस

हम विशिष्ट चरणों पर विचार करने के लिए आगे बढ़ते हैं।

2.1 अप्रयुक्त कोड हटाएं

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

#if defined(__BORLANDC__) || defined(__MINGW32__) # define XMD_H 1 #endif</code> < code > #if 0 extern const int jpeg_zigzag_order [ ] ; #endif

#if defined(__BORLANDC__) || defined(__MINGW32__) <br/> 
      

        
        
        
      

     # define XMD_H 1 <br/> 
      

        
        
        
      

     #endif</code> <br/> 
      

        
        
        
      

     <br/> 
      

        
        
        
      

     < code > #if 0 <br/> 
      

        
        
        
      

     extern const int jpeg_zigzag_order [ ] ; <br/> 
      

        
        
        
      

     #endif

कई मामलों में, अप्रयुक्त कार्यों को स्रोत कोड में पाया जा सकता है। उन्हें भी शाश्वत विश्राम के लिए भेजने की आवश्यकता है।

२.२ पूर्वप्रक्रमक और सशर्त संकलन

अक्सर सशर्त संकलन का उपयोग किसी प्रोग्राम के विशेष संस्करण बनाने के लिए किया जाता है। ऐसा तब होता है जब #define की मदद से एक या कई फाइलों में यह कॉन्फ़िगर किया जाता है कि संकलन के दौरान क्या उपयोग किया जाएगा, और अन्य फ़ाइलों में कोड # ifdef / # एंडिफ में संलग्न है। एक उदाहरण:

/*jconfig.h for Microsoft Visual C++ on Windows 95 or NT. */ ..... #define BMP_SUPPORTED #define GIF_SUPPORTED ..... /* wrbmp.c */ .... #ifdef BMP_SUPPORTED ... #endif /* BMP_SUPPORTED */

/*jconfig.h for Microsoft Visual C++ on Windows 95 or NT. */ <br/> 
      

        
        
        
      

     .....<br/> 
      

        
        
        
      

     #define BMP_SUPPORTED <br/> 
      

        
        
        
      

     #define GIF_SUPPORTED <br/> 
      

        
        
        
      

     .....<br/> 
      

        
        
        
      

     <br/> 
      

        
        
        
      

     /* wrbmp.c  */ <br/> 
      

        
        
        
      

     ....<br/> 
      

        
        
        
      

     #ifdef BMP_SUPPORTED <br/> 
      

        
        
        
      

     ...<br/> 
      

        
        
        
      

     #endif /* BMP_SUPPORTED */

मैं तुरंत चुनने की सलाह देता हूं कि क्या उपयोग किया जाएगा और सशर्त संकलन से छुटकारा मिलेगा। उदाहरण के लिए, यदि आप तय करते हैं कि BMP छवियों के लिए समर्थन आवश्यक है, तो आपको पूरे कोड से #ifdef BMP_SUPPORTED कमांड को निकालना होगा।

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

यह प्रीप्रोसेसर के साथ काम समाप्त नहीं करता है। आपको उन प्रीप्रोसेसर कमांड्स को खोजने की ज़रूरत है जो फ़ंक्शंस का अनुकरण करते हैं, और उन्हें पूर्ण कार्यों के साथ प्रतिस्थापित करते हैं।

#define CACHE_STATE(tif, sp) do { \ BitAcc = sp -> data ; \ BitsAvail = sp -> bit ; \ EOLcnt = sp -> EOLcnt ; \ cp = ( unsigned char * ) tif -> tif_rawcp ; \ ep = cp + tif -> tif_rawcc ; \ } while ( 0 )

#define CACHE_STATE(tif, sp) do { \ <br/> 
      

        
        
        
      

     BitAcc = sp -> data ; \<br/> 
      

        
        
        
      

     BitsAvail = sp -> bit ; \<br/> 
      

        
        
        
      

     EOLcnt = sp -> EOLcnt ; \<br/> 
      

        
        
        
      

     cp = ( unsigned char * ) tif -> tif_rawcp ; \<br/> 
      

        
        
        
      

     ep = cp + tif -> tif_rawcc ; \<br/> 
      

        
        
        
      

     } while ( 0 )

फ़ंक्शन हस्ताक्षर को सही ढंग से संकलित करने के लिए, आपको सभी चर के प्रकारों को जानना होगा। ध्यान दें कि चर BitAcc, BitsAvail, EOLcnt, cp, और ep को निर्दिष्ट मान हैं। ये चर नए फ़ंक्शन के पैरामीटर बन जाएंगे, और आपको उन्हें संदर्भ द्वारा पास करने की आवश्यकता है। यही है, उदाहरण के लिए, बिटकॉइन के लिए आपको uint32 और फ़ंक्शन हस्ताक्षर लिखने की आवश्यकता है।

कभी-कभी प्रोग्रामर प्रीप्रोसेसर आदेशों का दुरुपयोग करते हैं। इस तरह के दुरुपयोग का एक वास्तविक उदाहरण देखें:

#define HUFF_DECODE(result,state,htbl,failaction,slowlabel) \ { register int nb, look ; \ if ( bits_left < HUFF_LOOKAHEAD ) { \ if ( ! jpeg_fill_bit_buffer ( & state,get_buffer,bits_left, 0 ) ) { failaction ; } \ get_buffer = state. get_buffer ; bits_left = state. bits_left ; \ if ( bits_left < HUFF_LOOKAHEAD ) { \ nb = 1 ; goto slowlabel ; \ } \ } \ look = PEEK_BITS ( HUFF_LOOKAHEAD ) ; \ if ( ( nb = htbl -> look_nbits [ look ] ) != 0 ) { \ DROP_BITS ( nb ) ; \ result = htbl -> look_sym [ look ] ; \ } else { \ nb = HUFF_LOOKAHEAD + 1 ; \ slowlabel : \ if ( ( result = jpeg_huff_decode ( & state,get_buffer,bits_left,htbl,nb ) ) < 0 ) \ { failaction ; } \ get_buffer = state. get_buffer ; bits_left = state. bits_left ; \ } \ }

#define HUFF_DECODE(result,state,htbl,failaction,slowlabel) \ <br/> 
      

        
        
        
      

     { register int nb, look ; \<br/> 
      

        
        
        
      

     if ( bits_left < HUFF_LOOKAHEAD ) { \<br/> 
      

        
        
        
      

     if ( ! jpeg_fill_bit_buffer ( & state,get_buffer,bits_left, 0 ) ) { failaction ; } \<br/> 
      

        
        
        
      

     get_buffer = state. get_buffer ; bits_left = state. bits_left ; \<br/> 
      

        
        
        
      

     if ( bits_left < HUFF_LOOKAHEAD ) { \<br/> 
      

        
        
        
      

     nb = 1 ; goto slowlabel ; \<br/> 
      

        
        
        
      

     } \<br/> 
      

        
        
        
      

     } \<br/> 
      

        
        
        
      

     look = PEEK_BITS ( HUFF_LOOKAHEAD ) ; \<br/> 
      

        
        
        
      

     if ( ( nb = htbl -> look_nbits [ look ] ) != 0 ) { \<br/> 
      

        
        
        
      

     DROP_BITS ( nb ) ; \<br/> 
      

        
        
        
      

     result = htbl -> look_sym [ look ] ; \<br/> 
      

        
        
        
      

     } else { \<br/> 
      

        
        
        
      

     nb = HUFF_LOOKAHEAD + 1 ; \<br/> 
      

        
        
        
      

     slowlabel : \<br/> 
      

        
        
        
      

     if ( ( result = jpeg_huff_decode ( & state,get_buffer,bits_left,htbl,nb ) ) < 0 ) \<br/> 
      

        
        
        
      

     { failaction ; } \<br/> 
      

        
        
        
      

     get_buffer = state. get_buffer ; bits_left = state. bits_left ; \<br/> 
      

        
        
        
      

     } \<br/> 
      

        
        
        
      

     }

उपरोक्त कोड में, PEEK_BITS और DROP_BITS भी "फ़ंक्शन" हैं जो उसी तरह से बनाए गए हैं जैसे कि HUFF_DECITE। इस स्थिति में, परिवर्तन को आसान बनाने के लिए HUFF_DECODE में "फ़ंक्शन" कोड PEEK_BITS और DROP_BITS को पूरी तरह से शामिल करना उचित होगा।

केवल हानिरहित पूर्वप्रक्रमक कमांड के बने रहने के बाद आप कोड शोधन के अगले चरण में आगे बढ़ सकते हैं:

#define DATATYPE_VOID 0

2.3 स्विच और गोटो स्टेटमेंट

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

अगले चरण में, मैं लापता ब्रेक वाले मामलों के लिए सभी स्विच निर्माणों की जांच करता हूं।

switch ( test1 ( buf ) ) { case - 1 : if ( line != buf + ( bufsize - 1 ) ) continue ; /* falls through */ default : fputs ( buf, out ) ; break ; }

switch ( test1 ( buf ) ) <br/> 
      

        
        
        
      

     { <br/> 
      

        
        
        
      

     case - 1 : <br/> 
      

        
        
        
      

     if ( line != buf + ( bufsize - 1 ) ) <br/> 
      

        
        
        
      

     continue ; <br/> 
      

        
        
        
      

     /* falls through */ <br/> 
      

        
        
        
      

     default : <br/> 
      

        
        
        
      

     fputs ( buf, out ) ; <br/> 
      

        
        
        
      

     break ; <br/> 
      

        
        
        
      

     }

यह C / C ++ में अनुमत है, लेकिन C # में निषिद्ध है। इस तरह के स्विच स्टेटमेंट को या तो कई द्वारा बदला जा सकता है अगर ब्लॉक, या, अगर फाल्ट के साथ एक मामले में कुछ पंक्तियाँ शामिल हैं, तो कॉमन कोड की नकल करें।

२.४ हम पत्थर इकट्ठा करते हैं

पहले वर्णित सभी चीजों को आगे के कार्यों की तुलना में काफी कम समय की आवश्यकता होती है। इस तरह का पहला बड़े पैमाने का काम कक्षाओं में डेटा और कार्यों को इकट्ठा करना है। लक्ष्य एक ऐसी स्थिति है जहां प्रत्येक फ़ंक्शन एक कक्षा की एक विधि है।

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

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

नीचे दिए गए उदाहरण पर विचार करें:

struct tiff { char * tif_name ; int tif_fd ; int tif_mode ; uint32 tif_flags ; ...... } ; ...... extern int TIFFDefaultDirectory ( tiff * ) ; extern void _TIFFSetDefaultCompressionState ( tiff * ) ; extern int TIFFSetCompressionScheme ( tiff * , int ) ; ......

struct tiff<br/> 
      

        
        
        
      

     { <br/> 
      

        
        
        
      

     char * tif_name ; <br/> 
      

        
        
        
      

     int tif_fd ; <br/> 
      

        
        
        
      

     int tif_mode ; <br/> 
      

        
        
        
      

     uint32 tif_flags ; <br/> 
      

        
        
        
      

     ......<br/> 
      

        
        
        
      

     } ; <br/> 
      

        
        
        
      

     ......<br/> 
      

        
        
        
      

     extern int TIFFDefaultDirectory ( tiff * ) ; <br/> 
      

        
        
        
      

     extern void _TIFFSetDefaultCompressionState ( tiff * ) ; <br/> 
      

        
        
        
      

     extern int TIFFSetCompressionScheme ( tiff * , int ) ; <br/> 
      

        
        
        
      

     ......

यह देखना आसान है कि टिफ़ संरचना केवल एक वर्ग बनने के लिए भीख माँगती है, और नीचे घोषित तीन कार्य इस वर्ग के सार्वजनिक तरीके हैं। इसलिए यह संरचना को कक्षा में बदलने और कार्यों को कक्षा के स्थिर तरीके बनाने के लायक है।

जैसे-जैसे अधिकांश कार्य कक्षा के तरीके बनते हैं, यह समझना आसान हो जाएगा कि शेष "मुक्त" कार्यों के साथ क्या करना है। यह मत भूलो कि सभी कार्य सार्वजनिक तरीके नहीं बनेंगे। आमतौर पर बाहरी उपयोग के लिए कई सहायक कार्य नहीं होते हैं। ऐसे सहायक कार्य निजी तरीके बन जाएंगे।

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

2.5 फिर से प्रीप्रोसेसर और मल्टीपल इनहेरिटेंस

वर्गों और संरचनाओं के एक सेट से कक्षाओं का एक सेट प्राप्त होने के बाद, प्रीप्रोसेसर पर लौटने का समय है। अधिक सटीक रूप से, नीचे दिए गए की तरह परिभाषित करना (आपको इस बिंदु पर दूसरों को नहीं करना चाहिए):

#define STRIP_SIZE_DEFAULT 8192

इस तरह की परिभाषाओं को स्थिरांक में बदलना होगा और उस वर्ग को चुनना होगा जो उनका मालिक बन जाएगा। कार्यों के साथ, नव निर्मित स्थिरांक के लिए, आपको एक वर्ग बनाने की आवश्यकता हो सकती है (उदाहरण के लिए, स्थिरांक)। कार्यों की तरह, स्थिरांक सार्वजनिक या निजी बन सकते हैं।

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

class A { public : virtual bool DoSomething ( ) = 0 ; } ; class B { public : virtual bool DoAnother ( ) = 0 ; } ; class C : public A, B { ...... } ;

class A<br/> 
      

        
        
        
      

     { <br/> 
      

        
        
        
      

     public : <br/> 
      

        
        
        
      

     virtual bool DoSomething ( ) = 0 ; <br/> 
      

        
        
        
      

     } ; <br/> 
      

        
        
        
      

     class B<br/> 
      

        
        
        
      

     { <br/> 
      

        
        
        
      

     public : <br/> 
      

        
        
        
      

     virtual bool DoAnother ( ) = 0 ; <br/> 
      

        
        
        
      

     } ; <br/> 
      

        
        
        
      

     class C : public A, B<br/> 
      

        
        
        
      

     { ...... } ;

ऐसे ए और बी को इंटरफेस के रूप में घोषित करके ऐसे कई उत्तराधिकार आसानी से C # में स्थानांतरित किए जा सकते हैं।

2.6 टंकण कथन

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

typedef vector<Command*> Commands;

मैं ऐसे निर्माणों को एम्बेड करना पसंद करता हूं, अर्थात, कमांड कोड को वेक्टर <कमांड *> में बदल दें, और इसे हटा दें।

अधिक दिलचस्प निम्नलिखित टाइप किए गए एप्लिकेशन हैं:

typedef signed char int8 ; typedef unsigned char uint8 ; typedef short int16 ; typedef unsigned short uint16 ; typedef int int32 ; typedef unsigned int uint32 ;

typedef signed char int8 ; <br/> 
      

        
        
        
      

     typedef unsigned char uint8 ; <br/> 
      

        
        
        
      

     typedef short int16 ; <br/> 
      

        
        
        
      

     typedef unsigned short uint16 ; <br/> 
      

        
        
        
      

     typedef int int32 ; <br/> 
      

        
        
        
      

     typedef unsigned int uint32 ;

यहां यह उत्पन्न प्रकार के नामों पर ध्यान देने योग्य है। जाहिर है, typedef कम int16 है; और typedef int int32; बल्कि एक बाधा है, जिसका अर्थ है कि int16 को कोड में संक्षिप्त में बदलना बेहतर है, और int32 को int में। लेकिन बाकी टाइपफाइफ बहुत उपयोगी है। यह केवल उनके नामों को थोड़ा समायोजित करने के लिए समझ में आता है ताकि वे सी # में टाइप नामों से मेल खाएं। यही है, यह करें:

typedef signed char sbyte ; typedef unsigned char byte ; typedef unsigned short ushort typedef unsigned int uint ;

typedef signed char sbyte ; <br/> 
      

        
        
        
      

     typedef unsigned char byte ; <br/> 
      

        
        
        
      

     typedef unsigned short ushort <br/> 
      

        
        
        
      

     typedef unsigned int uint ;

ऐसे डिजाइनों पर विशेष ध्यान दिया जाना चाहिए:

typedef unsigned char JBLOCK[64]; /* one block of coefficients */

यह निर्माण 64 अहस्ताक्षरित प्रकार के चार वर्णों के लिए JBLOCK नाम का परिचय देता है। मैं ऐसे निर्माणों को कक्षाओं में बदलना पसंद करता हूं। अर्थात्, JBLOCK को एक ऐसा वर्ग बनाते हैं, जिसमें एक सरणी होती है, और सरणी के तत्वों तक पहुंचने के लिए तरीके प्रदान करते हैं। यह दृष्टिकोण इस बात की समझ को बहुत सरल करता है कि जेबीएलईसी सरणियों को कैसे बनाया और हटाया जाता है (विशेष रूप से 2-आयामी और 3-आयामी), साथ ही साथ वे कार्यक्रम के दौरान कैसे बदलते हैं।

2.7 बिंदुओं के अंकगणित

एक और बड़े पैमाने पर कार्य सूचक अंकगणित (पॉइंटर-अंकगणित) से छुटकारा पाने के लिए है। कई C / C ++ प्रोग्राम भाषा की इस विशेषता पर बहुत अधिक निर्भर करते हैं। उदाहरण के लिए:

void horAcc32 ( int stride, uint * wp, int wc ) { if ( wc > stride ) { wc -= stride ; do { wp [ stride ] += wp [ 0 ] ; wp ++; wc -= stride ; } while ( ( int ) wc > 0 ) ; } }

void horAcc32 ( int stride, uint * wp, int wc ) <br/> 
      

        
        
        
      

     { <br/> 
      

        
        
        
      

     if ( wc > stride ) { <br/> 
      

        
        
        
      

     wc -= stride ; <br/> 
      

        
        
        
      

     do { <br/> 
      

        
        
        
      

     wp [ stride ] += wp [ 0 ] ; <br/> 
      

        
        
        
      

     wp ++; <br/> 
      

        
        
        
      

     wc -= stride ; <br/> 
      

        
        
        
      

     } while ( ( int ) wc > 0 ) ; <br/> 
      

        
        
        
      

     } <br/> 
      

        
        
        
      

     }

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

void horAcc32 ( int stride, uint * wp, int wc ) { int wpPos = 0 ; if ( wc > stride ) { wc -= stride ; do { wp [ wpPos + stride ] += wp [ wpPos ] ; wpPos ++; wc -= stride ; } while ( ( int ) wc > 0 ) ; } }

void horAcc32 ( int stride, uint * wp, int wc ) <br/> 
      

        
        
        
      

     { <br/> 
      

        
        
        
      

     int wpPos = 0 ; <br/> 
      

        
        
        
      

     if ( wc > stride ) { <br/> 
      

        
        
        
      

     wc -= stride ; <br/> 
      

        
        
        
      

     do { <br/> 
      

        
        
        
      

     wp [ wpPos + stride ] += wp [ wpPos ] ; <br/> 
      

        
        
        
      

     wpPos ++; <br/> 
      

        
        
        
      

     wc -= stride ; <br/> 
      

        
        
        
      

     } while ( ( int ) wc > 0 ) ; <br/> 
      

        
        
        
      

     } <br/> 
      

        
        
        
      

     }

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

विशेष रूप से उन कार्यों पर ध्यान दिया जाना चाहिए जो इस प्रक्रिया में, उनके पास पारित बिंदुओं को बदलते हैं। मूल कार्य के भिन्न:

void horAcc32(int stride, uint* & wp, int wc)

इस स्थिति में, जब wAcc32 फ़ंक्शन में wp बदलता है, तो कॉलिंग फ़ंक्शन में सूचक भी बदलता है। इस मामले में सूचकांक दृष्टिकोण का भी उपयोग किया जा सकता है। आपको बस कॉलिंग फ़ंक्शन में इंडेक्स दर्ज करना होगा और इसे horAcc32 में पास करना होगा।

void horAcc32(int stride, uint* wp, int& wpPos, int wc)

अक्सर इंट wpPos को एक क्लास फील्ड (सदस्य चर) बनाना सुविधाजनक होता है।

2.8 समारोह संकेत

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

फ़ंक्शन पॉइंटर्स एक ही वर्ग / फ़ंक्शन के भीतर बनाए और उपयोग किए जाते हैं
फ़ंक्शन पॉइंटर्स प्रोग्राम के विभिन्न वर्गों द्वारा बनाए और उपयोग किए जाते हैं
कार्यों के संकेत उपयोगकर्ताओं द्वारा बनाए जाते हैं और कार्यक्रम में स्थानांतरित किए जाते हैं (इस मामले में कार्यक्रम एक स्थिर या गतिशील रूप से भरी हुई लाइब्रेरी है)

पहले मामले के लिए एक उदाहरण:

typedef int ( * func ) ( int x, int y ) ; class Calculator { Calculator ( ) ; int ( * func ) ( int x, int y ) ; static int sum ( int x, int y ) { return x + y ; } static int mul ( int x, int y ) { return x * y ; } public : static Calculator * CreateSummator ( ) { Calculator * c = new Calculator ( ) ; c -> func = sum ; return c ; } static Calculator * CreateMultiplicator ( ) { Calculator * c = new Calculator ( ) ; c -> func = mul ; return c ; } int Calc ( int x, int y ) { return ( * func ) ( x,y ) ; } } ;

typedef int ( * func ) ( int x, int y ) ; <br/> 
      

        
        
        
      

     <br/> 
      

        
        
        
      

     class Calculator<br/> 
      

        
        
        
      

     { <br/> 
      

        
        
        
      

     Calculator ( ) ; <br/> 
      

        
        
        
      

     int ( * func ) ( int x, int y ) ; <br/> 
      

        
        
        
      

     <br/> 
      

        
        
        
      

     static int sum ( int x, int y ) { return x + y ; } <br/> 
      

        
        
        
      

     static int mul ( int x, int y ) { return x * y ; } <br/> 
      

        
        
        
      

     public : <br/> 
      

        
        
        
      

     static Calculator * CreateSummator ( ) <br/> 
      

        
        
        
      

     { <br/> 
      

        
        
        
      

     Calculator * c = new Calculator ( ) ; <br/> 
      

        
        
        
      

     c -> func = sum ; <br/> 
      

        
        
        
      

     return c ; <br/> 
      

        
        
        
      

     } <br/> 
      

        
        
        
      

     static Calculator * CreateMultiplicator ( ) <br/> 
      

        
        
        
      

     { <br/> 
      

        
        
        
      

     Calculator * c = new Calculator ( ) ; <br/> 
      

        
        
        
      

     c -> func = mul ; <br/> 
      

        
        
        
      

     return c ; <br/> 
      

        
        
        
      

     } <br/> 
      

        
        
        
      

     int Calc ( int x, int y ) { return ( * func ) ( x,y ) ; } <br/> 
      

        
        
        
      

     } ;

इस स्थिति में, निर्मित वर्ग में Calc पद्धति की कार्यक्षमता CreateSummator या CreateMultiplicator विधियों में से किस पर निर्भर करती है। मैं कक्षा में एक आंतरिक एनम बनाना पसंद करता हूं, जो फंक के लिए सभी संभावित विकल्पों का वर्णन करता है, और एक ऐसा क्षेत्र जो एनम से मूल्य को संग्रहीत करता है। फिर, एक फ़ंक्शन पॉइंटर के बजाय, मैं एक विधि बनाता हूं जिसमें एक स्विच स्टेटमेंट (या कई इफ़्स) शामिल हैं। बनाई गई विधि उस फ़ील्ड के मूल्य के आधार पर कॉल करने के लिए कौन से फ़ंक्शन का चयन करती है। संशोधित विकल्प:

class Calculator { enum FuncType { ftSum, ftMul } ; FuncType type ; Calculator ( ) ; int func ( int x, int y ) { if ( type == ftSum ) return sum ( x,y ) ; return mul ( x,y ) ; } static int sum ( int x, int y ) { return x + y ; } static int mul ( int x, int y ) { return x * y ; } public : static Calculator * createSummator ( ) { Calculator * c = new Calculator ( ) ; c -> type = ftSum ; return c ; } static Calculator * createMultiplicator ( ) { Calculator * c = new Calculator ( ) ; c -> type = ftMul ; return c ; } int Calc ( int x, int y ) { return func ( x,y ) ; } } ;

class Calculator<br/> 
      

        
        
        
      

     { <br/> 
      

        
        
        
      

     enum FuncType<br/> 
      

        
        
        
      

     { ftSum, ftMul } ; <br/> 
      

        
        
        
      

     FuncType type ; <br/> 
      

        
        
        
      

     <br/> 
      

        
        
        
      

     Calculator ( ) ; <br/> 
      

        
        
        
      

     <br/> 
      

        
        
        
      

     int func ( int x, int y ) <br/> 
      

        
        
        
      

     { <br/> 
      

        
        
        
      

     if ( type == ftSum ) <br/> 
      

        
        
        
      

     return sum ( x,y ) ; <br/> 
      

        
        
        
      

     return mul ( x,y ) ; <br/> 
      

        
        
        
      

     } <br/> 
      

        
        
        
      

     <br/> 
      

        
        
        
      

     static int sum ( int x, int y ) { return x + y ; } <br/> 
      

        
        
        
      

     static int mul ( int x, int y ) { return x * y ; } <br/> 
      

        
        
        
      

     public : <br/> 
      

        
        
        
      

     static Calculator * createSummator ( ) <br/> 
      

        
        
        
      

     { <br/> 
      

        
        
        
      

     Calculator * c = new Calculator ( ) ; <br/> 
      

        
        
        
      

     c -> type = ftSum ; <br/> 
      

        
        
        
      

     return c ; <br/> 
      

        
        
        
      

     } <br/> 
      

        
        
        
      

     static Calculator * createMultiplicator ( ) <br/> 
      

        
        
        
      

     { <br/> 
      

        
        
        
      

     Calculator * c = new Calculator ( ) ; <br/> 
      

        
        
        
      

     c -> type = ftMul ; <br/> 
      

        
        
        
      

     return c ; <br/> 
      

        
        
        
      

     } <br/> 
      

        
        
        
      

     int Calc ( int x, int y ) { return func ( x,y ) ; } <br/> 
      

        
        
        
      

     } ;

आप अन्यथा कर सकते हैं: अभी तक कुछ भी न बदलें, लेकिन सी # के पोर्टिंग के समय प्रतिनिधियों का उपयोग करें।

दूसरे मामले के लिए एक उदाहरण (कार्यों के लिए संकेत कार्यक्रम के विभिन्न वर्गों द्वारा बनाए और उपयोग किए जाते हैं):

typedef int ( * TIFFVSetMethod ) ( TIFF * , ttag_t, va_list ) ; typedef int ( * TIFFVGetMethod ) ( TIFF * , ttag_t, va_list ) ; typedef void ( * TIFFPrintMethod ) ( TIFF * , FILE * , long ) ; class TIFFTagMethods { public : TIFFVSetMethod vsetfield ; TIFFVGetMethod vgetfield ; TIFFPrintMethod printdir ; } ;

typedef int ( * TIFFVSetMethod ) ( TIFF * , ttag_t, va_list ) ; <br/> 
      

        
        
        
      

     typedef int ( * TIFFVGetMethod ) ( TIFF * , ttag_t, va_list ) ; <br/> 
      

        
        
        
      

     typedef void ( * TIFFPrintMethod ) ( TIFF * , FILE * , long ) ; <br/> 
      

        
        
        
      

     <br/> 
      

        
        
        
      

     class TIFFTagMethods<br/> 
      

        
        
        
      

     { <br/> 
      

        
        
        
      

     public : <br/> 
      

        
        
        
      

     TIFFVSetMethod  vsetfield ; <br/> 
      

        
        
        
      

     TIFFVGetMethod  vgetfield ; <br/> 
      

        
        
        
      

     TIFFPrintMethod  printdir ; <br/> 
      

        
        
        
      

     } ;

मैं vsetfield / vgetfield / printdir को आभासी तरीकों में बदलकर इस स्थिति को बदलना पसंद करता हूं। Vsetfield / vgetfield / printdir द्वारा उपयोग किया जाने वाला कोड TIFFTagMethods से वर्चुअल तरीकों के आवश्यक कार्यान्वयन के साथ वंशज कक्षाएं बनाएगा।

तीसरे मामले के लिए एक उदाहरण (कार्यों के लिए संकेत उपयोगकर्ताओं द्वारा बनाए गए हैं और कार्यक्रम में पारित किए गए हैं):

typedef int (*PROC)(int, int); 
      

        
        
        
      

     int DoUsingMyProc (int, int, PROC lpMyProc, …);

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

2.9 "समस्या" कोड को अलग करना

मूल कोड में अंतिम परिवर्तन सब कुछ को अलग करना है जो संकलक को बदलते समय समस्याएं पैदा कर सकता है। यह, उदाहरण के लिए, कोड जो सक्रिय रूप से मानक C / C ++ लाइब्रेरी का उपयोग करता है (fprintf, get, atof, आदि जैसे कार्य) या WinAPI। C # में, इस तरह के कोड को .NET फ्रेमवर्क से विधियों का उपयोग करने के लिए संशोधित करना होगा या, यदि आवश्यक हो, तो पी / इनवोक। इस मामले में, मैं आपको साइट http://www.pinvoke.net पर देखने की सलाह देता हूं।

"समस्या कोड" जितना संभव हो उतना स्थानीयकृत किया जाना चाहिए। ऐसा करने के लिए, आप स्थैतिक विधियों के साथ एक वर्ग बना सकते हैं, जो मानक C / C ++ पुस्तकालय और WinAPI के आसपास एक आवरण होगा। फिर, स्थानांतरण के दौरान, केवल इस आवरण को बदलना होगा।

2.10 संकलक को बदलना

"सत्य का क्षण" आ गया है - परिवर्तित कोड को C # संकलक द्वारा संकलित परियोजना में स्थानांतरित करने का समय है। यहां सब कुछ काफी सरल है, यद्यपि श्रमसाध्य। एक खाली प्रोजेक्ट बनाना आवश्यक है, फिर इसमें आवश्यक कक्षाएं जोड़ें, समान मूल कक्षाओं से कोड को इन कक्षाओं में कॉपी करें।

इस प्रक्रिया में, आपको अनावश्यक (विभिन्न #include, उदाहरण के लिए) को हटाना होगा और कॉस्मेटिक परिवर्तन करना होगा। "मानक" परिवर्तन:

.h और .cpp फ़ाइलों से संयोजन कोड
obj.method () के साथ obj-> तरीका () बदलना
क्लास की जगह :: StaticMethod with Class.StaticMethod
डिलीट * इन फंक (ए * एनस्टांस)
फंक (इंट & एक्स) की जगह फंक (रेफ इंट एक्स)

अधिकांश परिवर्तन वास्तव में मुश्किल नहीं हैं, लेकिन कभी-कभी आपको कोड के हिस्से पर टिप्पणी करनी होगी। मूल रूप से, मुझे समस्याग्रस्त कोड पर टिप्पणी करनी होगी, जिस पर खंड 2.9 में चर्चा की गई थी। मुख्य लक्ष्य C # में संकलित कोड प्राप्त करना है। सबसे अधिक संभावना है, यह काम नहीं करेगा, लेकिन सब कुछ का अपना समय है।

2.11 फ़ाइल

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

बाइट सरणी (और इसके विपरीत) से स्ट्रिंग्स बनाते समय, आपको सावधानी से उपयोग किए गए एन्कोडिंग का चयन करना होगा। आपको Encoding.ASCII का उपयोग नहीं करना चाहिए, क्योंकि यह 7-बिट है और बाइट्स के लिए 127 से अधिक है जो आपको मिलता है? '' पात्रों के बजाय। वर्तमान एन्कोडिंग एन्कोडिंग का उपयोग करना बेहतर है। डीफॉल्ट या एनकोडिंग। गेटएन्कोडिंग ("लैटिन 1")। एन्कोडिंग का विकल्प पाठ या बाइट्स के साथ आगे क्या होता है पर निर्भर करता है। यदि पाठ को उपयोगकर्ता को दिखाया जाना आवश्यक है, तो एन्कोडिंग.फॉल्ट का उपयोग करना बेहतर है, और यदि बाइट को बाइनरी फ़ाइल में लिखने के लिए पाठ से बाइट्स बनाया जाता है, तो एन्कोडिंग का उपयोग करना बेहतर होता है। GetEncoding ("Latin1)"।

कुछ समस्याएँ स्वरूपित स्ट्रिंग्स (C / C ++ में फ़ंक्शन का प्रिंटफ़ परिवार) के आउटपुट का गठन कर सकती हैं। .NET में String.Format की कार्यक्षमता दोनों सुविधाओं में भिन्न है (यह खराब है) और प्रारूप स्ट्रिंग सिंटैक्स में। इस समस्या को दो तरीकों से हल किया जा सकता है:

एक वर्ग बनाएं जो प्रिंटफ फ़ंक्शन के समान होगा
स्वरूपण लाइनों को बदलें ताकि String.Format समान परिणाम देता है (हमेशा संभव नहीं)

यदि आप पहले रास्ते पर जाते हैं, तो आपको "सी # में एक प्रिंटफ़ कार्यान्वयन" के मौजूदा कार्यान्वयन पर ध्यान देना चाहिए।

मैं दूसरा तरीका पसंद करता हूं। यदि आप इसके साथ जाते हैं, तो "c # प्रारूप विनिर्देशक" (बिना उद्धरण के) और "प्रारूप विनिर्देशक परिशिष्ट में C # से संक्षेप में " पर Google मदद करेगा।

पोर्ट किए गए कोड का उपयोग करने वाले सभी परीक्षणों को सफलतापूर्वक निष्पादित करने के बाद, यह कहना सुरक्षित होगा कि पोर्ट पूरा हो गया है। अब हम यह याद कर सकते हैं कि कोड अभी तक "C # की भावना में" काफी नहीं है (उदाहरण के लिए, गुणों के बजाय get- / set- विधियों का उपयोग किया जाता है) और हस्तांतरित कोड का पुनःसंक्रमण करें। आप बाधाओं को खोजने और अनुकूलन करने के लिए प्रोफाइलर का उपयोग कर सकते हैं। लेकिन यह पूरी तरह से अलग कहानी है।

आपके पोर्टिंग के साथ शुभकामनाएँ!

PS यह लेख मेरा नहीं है, जो सर्जियस बोब्रोवस्की द्वारा लिखा गया है, जिनके पास अभी भी हैबर के लिए निमंत्रण नहीं है। यदि किसी के पास मुफ्त है और साझा करने में कोई आपत्ति नहीं है, तो कृपया एक व्यक्तिगत में लिखें।

नई वास्तविकताओं के लिए पुराना कोड पैना करें