C ++ टेम्प्लेट का उपयोग करके डेटा जनरेशन

एक बार कुछ छोटे कार्यक्रम को लिखने के लिए कार्य निर्धारित किया गया था, तो उसे कुछ करना था, लेकिन साथ ही साथ यह संभव हो गया था कि जितना संभव हो उतने ही विघटन के दौरान कोड विश्लेषण की प्रक्रिया को जटिल किया जाए। तरीकों में से एक है एक्सए से इस्तेमाल किए गए विनएपीआई कार्यों के सभी संदर्भों को हटाने के लिए, और यह WinApi फ़ंक्शन नामों को नहीं स्टोर करने का निर्णय लिया गया था, लेकिन कुछ हैश कोड की गणना एक सरल एल्गोरिथ्म के साथ कुछ धागे द्वारा की जाती है। फिर, dll लाइब्रेरी के सभी फ़ंक्शंस की गणना करते समय, इन हैश कोड द्वारा आपकी ज़रूरत का पता लगाएं। सबसे अधिक इस्तेमाल की जाने वाली विधियों में से एक छोटी उपयोगिता लिखना है, इसे आवश्यक कार्यों के नामों की एक इनपुट सूची दें, यह उनके हैश कोड की गणना करता है और आउटपुट में वह स्रोत देता है जहां कोड के साथ समाप्त तालिका स्थित है। तब यह स्रोत कोड प्रोजेक्ट से जुड़ा होता है और फिर पूर्ण पर उपयोग किया जाता है। लेकिन हमेशा की तरह आलस्य ने हस्तक्षेप किया। इस तरह की उपयोगिता को लिखने के लिए बहुत आलसी था, और यहां तक ​​कि मेक फ़ाइल में आवश्यक कार्यों को भी लिखता था। मैं चाहता था कि सब कुछ गणना के समय पर हो। तब C ++ टेम्प्लेट पर एक नज़र डाली गई थी ...



C ++ टेम्प्लेट टाइप char * के स्ट्रिंग्स के साथ काम करने की अनुमति नहीं देते हैं, आप उन्हें नहीं लिख सकते हैं, आप उनसे नहीं पढ़ सकते हैं, आप इसे आगे कहीं पास करने के लिए केवल एक पॉइंटर का उपयोग कर सकते हैं। लेकिन आलस्य एक जिद्दी चीज है, लेकिन क्या होगा यदि टेम्पलेट के पैरामीटर स्ट्रिंग को स्वयं नहीं, बल्कि अलग-अलग वर्णों को निर्दिष्ट करते हैं? यह पहले से ही बहुत अच्छा है, और टेम्प्लेट में डिफ़ॉल्ट पैरामीटर हो सकते हैं, जो वास्तव में हमें चाहिए। अब एक खाका वर्ग लिखना पर्याप्त है जिसके पैरामीटर वर्ण (चार प्रकार) होंगे और पैरामीटर मानों के आधार पर हैश की गणना करने के लिए एक फ़ंक्शन होगा, और यहां केवल कक्षा है:

template<char c01 = 0, char c02 = 0, char c03 = 0, char c04 = 0, char c05 = 0, char c06 = 0, char c07 = 0, char c08 = 0, char c09 = 0, char c10 = 0, char c11 = 0, char c12 = 0, char c13 = 0, char c14 = 0, char c15 = 0, char c16 = 0, char c17 = 0, char c18 = 0, char c19 = 0, char c20 = 0, char c21 = 0, char c22 = 0, char c23 = 0, char c24 = 0, char c25 = 0, char c26 = 0, char c27 = 0, char c28 = 0, char c29 = 0, char c30 = 0, char c31 = 0, char c32 = 0 > class hash_text { public: //   static unsigned int get_hash() { unsigned int hash = c01; if( c02 ) { hash ^= (hash << 8) | c02; } if( c03 ) { hash ^= (hash << 8) | c03; } if( c04 ) { hash ^= (hash << 8) | c04; } if( c05 ) { hash ^= (hash << 8) | c05; } if( c06 ) { hash ^= (hash << 8) | c06; } if( c07 ) { hash ^= (hash << 8) | c07; } if( c08 ) { hash ^= (hash << 8) | c08; } if( c09 ) { hash ^= (hash << 8) | c09; } if( c10 ) { hash ^= (hash << 8) | c10; } if( c11 ) { hash ^= (hash << 8) | c11; } if( c12 ) { hash ^= (hash << 8) | c12; } if( c13 ) { hash ^= (hash << 8) | c13; } if( c14 ) { hash ^= (hash << 8) | c14; } if( c15 ) { hash ^= (hash << 8) | c15; } if( c16 ) { hash ^= (hash << 8) | c16; } if( c17 ) { hash ^= (hash << 8) | c17; } if( c18 ) { hash ^= (hash << 8) | c18; } if( c19 ) { hash ^= (hash << 8) | c19; } if( c20 ) { hash ^= (hash << 8) | c20; } if( c21 ) { hash ^= (hash << 8) | c21; } if( c22 ) { hash ^= (hash << 8) | c22; } if( c23 ) { hash ^= (hash << 8) | c23; } if( c24 ) { hash ^= (hash << 8) | c24; } if( c25 ) { hash ^= (hash << 8) | c25; } if( c26 ) { hash ^= (hash << 8) | c26; } if( c27 ) { hash ^= (hash << 8) | c27; } if( c28 ) { hash ^= (hash << 8) | c28; } if( c29 ) { hash ^= (hash << 8) | c29; } if( c30 ) { hash ^= (hash << 8) | c30; } if( c31 ) { hash ^= (hash << 8) | c31; } if( c32 ) { hash ^= (hash << 8) | c32; } return hash; } };
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

जैसा कि आप देख सकते हैं, सब कुछ इतना जटिल नहीं है। इस वर्ग के लिए एकमात्र सीमा 32 से अधिक वर्णों की लंबाई के साथ तार का उपयोग करने की क्षमता है, लेकिन यदि आपको अधिक की आवश्यकता है, तो इसका विस्तार करना आसान है।

अब इस वर्ग का उपयोग कैसे करें? सब कुछ काफी सरल है, फ़ंक्शन का नाम लें और इसे टेम्पलेट मापदंडों में चरित्र-दर-वर्ण लिखें:

 typedef hash_text<'C','r','e','a','t','e','F','i','l','e'> hashCreateFile; //  
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

आप इसे कैसे पसंद करते हैं?



और खुद हैश पाने के लिए:

 hashCreateFile::get_hash();
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

और वह सब है! अब यह आवश्यक है कि फ़ंक्शन प्रकारों की आवश्यक संख्या घोषित की जाए और जहाँ आपको ज़रूरत हो, हैश का उपयोग करें।

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

लेकिन यह सीमा नहीं है, इस तरह यह अभी भी संकलन समय पर मक्खी पर सही तार को एन्क्रिप्ट करने के लिए संभव है।

स्ट्रिंग एन्क्रिप्शन

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

 template<unsigned int code, char c01 = 0, char c02 = 0, char c03 = 0, char c04 = 0, char c05 = 0, char c06 = 0, char c07 = 0, char c08 = 0, char c09 = 0, char c10 = 0, char c11 = 0, char c12 = 0, char c13 = 0, char c14 = 0, char c15 = 0, char c16 = 0, char c17 = 0, char c18 = 0, char c19 = 0, char c20 = 0, char c21 = 0, char c22 = 0, char c23 = 0, char c24 = 0, char c25 = 0, char c26 = 0, char c27 = 0, char c28 = 0, char c29 = 0, char c30 = 0, char c31 = 0, char c32 = 0 > class code_text { //     static const char count = (c01 ? 1 : 0) + (c02 ? 1 : 0) + (c03 ? 1 : 0) + (c04 ? 1 : 0) + (c05 ? 1 : 0) + (c06 ? 1 : 0) + (c07 ? 1 : 0) + (c08 ? 1 : 0) + (c09 ? 1 : 0) + (c10 ? 1 : 0) + (c11 ? 1 : 0) + (c12 ? 1 : 0) + (c13 ? 1 : 0) + (c14 ? 1 : 0) + (c15 ? 1 : 0) + (c16 ? 1 : 0) + (c17 ? 1 : 0) + (c18 ? 1 : 0) + (c19 ? 1 : 0) + (c20 ? 1 : 0) + (c21 ? 1 : 0) + (c22 ? 1 : 0) + (c23 ? 1 : 0) + (c24 ? 1 : 0) + (c25 ? 1 : 0) + (c26 ? 1 : 0) + (c27 ? 1 : 0) + (c28 ? 1 : 0) + (c29 ? 1 : 0) + (c30 ? 1 : 0) + (c31 ? 1 : 0) + (c32 ? 1 : 0); char buf[count + 1]; //     char encode_char( bool first, int bit, char b1, char b2 ) { if( b2 == 0 ) //  return b1; unsigned int change = code & (1 << bit); //    if( first ) return change ? b2 : b1; // 1-  else return change ? b1 : b2; // 2-  } //    , n -      bool put_char( int n, char c1, char c2 ) { if( c1 == 0 ) return false; //  buf[n] = encode_char( true, n / 2, c1, c2 ); if( c2 == 0 ) return false; //  buf[n + 1] = encode_char( false, n / 2, c1, c2 ); return true; } //   void encode() { int v = 0; //    ,  if   ,      ) if( put_char( 0, c01, c02 ) ) if( put_char( 2, c03, c04 ) ) if( put_char( 4, c05, c06 ) ) if( put_char( 6, c07, c08 ) ) if( put_char( 8, c09, c10 ) ) if( put_char( 10, c11, c12 ) ) if( put_char( 12, c13, c14 ) ) if( put_char( 14, c15, c16 ) ) if( put_char( 16, c17, c18 ) ) if( put_char( 18, c19, c20 ) ) if( put_char( 20, c21, c22 ) ) if( put_char( 22, c23, c24 ) ) if( put_char( 24, c25, c26 ) ) if( put_char( 26, c27, c28 ) ) if( put_char( 28, c29, c30 ) ) if( put_char( 30, c31, c32 ) ) v = 0; //   if   -  buf[count] = 0; } public: code_text() { encode(); } const char* ptr() const //    { return buf; } int len() { return count; } char* str( char* to ) { return decode( buf, count, to ); //  to } };
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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

 code_text<44717397, 'E','n','c','o','d','e','S','t','r','i','n','g'> EncodeString;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

एक ऑब्जेक्ट यहां बनाया गया है, और ऊपर नहीं - एक प्रकार। ठीक है, आप इसे इस तरह से लागू कर सकते हैं:

 printf( "%s\n", EncodeString.ptr() );
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

स्क्रीन में एक एन्क्रिप्टेड स्ट्रिंग होगी, या

 char to[33]; printf( "%s\n", EncodeString.str(to) );
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

स्क्रीन पर एक डिक्रिप्टेड स्ट्रिंग होगी। डिकोड फ़ंक्शन, निश्चित रूप से, कहीं न कहीं वर्णित किया जाना चाहिए।

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

क्षुधावर्धक

खैर, एक जलपान के लिए अभी भी एक ऐसा उदाहरण है। C ++ में अंतर्निहित बाइनरी संख्या नहीं है। लेकिन हम इस विधि का उपयोग करके इसे प्राप्त कर सकते हैं। नीचे एक वर्ग है जो 32-बिट संख्याओं को परिवर्तित कर सकता है:

 template<int c01 = -1, int c02 = -1, int c03 = -1, int c04 = -1, int c05 = -1, int c06 = -1, int c07 = -1, int c08 = -1, int c09 = -1, int c10 = -1, int c11 = -1, int c12 = -1, int c13 = -1, int c14 = -1, int c15 = -1, int c16 = -1, int c17 = -1, int c18 = -1, int c19 = -1, int c20 = -1, int c21 = -1, int c22 = -1, int c23 = -1, int c24 = -1, int c25 = -1, int c26 = -1, int c27 = -1, int c28 = -1, int c29 = -1, int c30 = -1, int c31 = -1, int c32 = -1 > class bin_to_dec { static unsigned int get_bit( int res, int c ) { return (res << 1) | (c ? 1 : 0); //c      0  1 } public: static unsigned int dec() { unsigned int res = 0; if( c01 >= 0 ) res = get_bit( res, c01 ); if( c02 >= 0 ) res = get_bit( res, c02 ); if( c03 >= 0 ) res = get_bit( res, c03 ); if( c04 >= 0 ) res = get_bit( res, c04 ); if( c05 >= 0 ) res = get_bit( res, c05 ); if( c06 >= 0 ) res = get_bit( res, c06 ); if( c07 >= 0 ) res = get_bit( res, c07 ); if( c08 >= 0 ) res = get_bit( res, c08 ); if( c09 >= 0 ) res = get_bit( res, c09 ); if( c10 >= 0 ) res = get_bit( res, c10 ); if( c11 >= 0 ) res = get_bit( res, c11 ); if( c12 >= 0 ) res = get_bit( res, c12 ); if( c13 >= 0 ) res = get_bit( res, c13 ); if( c14 >= 0 ) res = get_bit( res, c14 ); if( c15 >= 0 ) res = get_bit( res, c15 ); if( c16 >= 0 ) res = get_bit( res, c16 ); if( c17 >= 0 ) res = get_bit( res, c17 ); if( c18 >= 0 ) res = get_bit( res, c18 ); if( c19 >= 0 ) res = get_bit( res, c19 ); if( c20 >= 0 ) res = get_bit( res, c20 ); if( c21 >= 0 ) res = get_bit( res, c21 ); if( c22 >= 0 ) res = get_bit( res, c22 ); if( c23 >= 0 ) res = get_bit( res, c23 ); if( c24 >= 0 ) res = get_bit( res, c24 ); if( c25 >= 0 ) res = get_bit( res, c25 ); if( c26 >= 0 ) res = get_bit( res, c26 ); if( c27 >= 0 ) res = get_bit( res, c27 ); if( c28 >= 0 ) res = get_bit( res, c28 ); if( c29 >= 0 ) res = get_bit( res, c29 ); if( c30 >= 0 ) res = get_bit( res, c30 ); if( c31 >= 0 ) res = get_bit( res, c31 ); if( c32 >= 0 ) res = get_bit( res, c32 ); return res; } };
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इस तरह का उपयोग करें:

 typedef bin_to_dec<1,1,1,0,0,0,1,1,1> flags; printf( "%u", flags::dec() );
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अंतभाषण

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