उनके पते पर कॉलिंग फ़ंक्शन के लिए आवरण

आपका दिन शुभ हो!

एक सौदा हुआ - मैंने FTDI से USB मॉड्यूल के साथ काम करने के लिए एक इंटरफ़ेस बनाया। मुझे DLL-इंटरफ़ेस को जोड़ने के साथ बहुत ही सुंदर था। Microsoft Visual Studio 2008 ( UPD : तब मुझे इस विषय का पता चला) की स्वचालित लिंकिंग क्षमताओं से निराश होकर, मैंने मैन्युअल रूप से करने का निर्णय लिया। रास्ते में, मैं कई दर्जन कार्यों को मैन्युअल रूप से जोड़ने के लिए बहुत थक गया था। और फिर मैंने Google, C ++ और टेम्पलेट्स की ओर रुख किया। और अगर C ++ शैली में DLL का कनेक्शन कोई प्रश्न नहीं उठाता है, तो "त्रुटि = FT_Open (Num, & _Handler)" की शैली में जुड़े कार्यों के लिए सुविधाजनक कॉल, जहां FT_Open ऑब्जेक्ट तुरंत विफल हो गया। परिणाम (ऐसे कार्यों के लिए यहां) कट के तहत है। संक्षेप में - मैंने एक फ़ंक्शन पॉइंटर के चारों ओर लपेटा।

समस्या का बयान

तुरंत आरक्षण करें - मैं विंडोज एक्सपी प्रो, विजुअल स्टूडियो में काम करता हूं। यह फ़ंक्शन का पता प्राप्त करने के लिए महत्वपूर्ण है। हालांकि, फ़ंक्शन पॉइंटर्स के साथ काम करते समय, यह महत्वपूर्ण नहीं है।



खैर, उन लोगों के लिए जो विषय में नहीं हैं, यहां WinAPI का उपयोग करके FTD2XX.dll से बहुत FT_Open फ़ंक्शन खोजने का क्रम है:

#include "FTD2XX.h" //   FTDI typedef FT_STATUS (*pFT_Open) (int, FT_HANDLE *); //   " FT_OPEN" // ... HMODULE hMod = LoadLibrary ("FTD2XX.dll"); //   - . .   pFT_Open pOpen = GetProcAddress (hMod, "FT_Open"); //    -  . .   // ... FT_STATUS st = pOpen (0, &hDev); //   // ... FreeLibrary (hMod); //  
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

जब आपके पास एक फ़ंक्शन होता है, तो इससे कोई फर्क नहीं पड़ता, लेकिन इस लाइब्रेरी में मैंने 51 फ़ंक्शन गिनाए। और प्रत्येक के लिए मुझे निम्नलिखित करने की आवश्यकता है:

 typedef FT_STATUS (*pFT_Open) (int, FT_HANDLE *); //   "  " pFT_Open pOpen; //  "  " pFT_Open pOpen = GetProcAddress (hMod, "FT_Open"); //    "FT_Open"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

विशेष रूप से कष्टप्रद है टाइपपैड की एक गुच्छा उत्पन्न करने की आवश्यकता है। हाँ, मुझे पता है, आप बिना टाइप किए, लिख सकते हैं, लेकिन यह घृणित लगेगा!



इसलिए, मैं किसी तरह अपने जीवन को आसान बनाना चाहता हूं:

 Funct2<FT_STATUS, int, FT_HANDLE *> Open; //   " 2 " Open = GetProcAddress (hMod, "FT_Open"); //    "FT_Open" // ... FT_STATUS st = Open (0, &hDev); //  
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

निर्णय

प्रयोगों और मस्तिष्क के उबलने के दौरान, मुझे ऐसा क्लास टेम्पलेट मिला:

 template <typename Ret, typename Arg1, typename Arg2, typename Except = FunctPtrExceptionType, Except Value = FunctPtrExceptionDefValue> class Funct2 { public: typedef Ret (*tfPtr) (Arg1, Arg2); tfPtr fPtr; public: Funct2 (tfPtr Ptr = 0): fPtr (Ptr) {} Funct2 &operator= (void *Ptr) { fPtr = reinterpret_cast<tfPtr> (Ptr); return *this; } Ret operator () (Arg1 A1, Arg2 A2) throw (Except) { if (!fPtr) throw Except (Value); return fPtr (A1, A2); } }; // class Funct2
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

मुझे लगता है कि यहां सब कुछ प्राथमिक है, लेकिन फिर भी मैं समझा नहीं सकता।



एक कार्यात्मक 2 टेम्पलेट बनाया गया है, जो पहले पैरामीटर के रूप में फ़ंक्शन द्वारा लौटाए गए रिट प्रकार को सेट करता है। निम्नलिखित दो पैरामीटर - Arg1 और Arg2 - फ़ंक्शन तर्क के प्रकार निर्दिष्ट करते हैं। त्रुटि हैंडलिंग को सार्वभौमिक बनाने के लिए, अपवाद के प्रकार और उसके मूल्य मान को सेट किया जाता है (डिफ़ॉल्ट पैरामीटर #define FunctPtrExceptionType और #define FunctPtrExceptionDefValue पर सेट हैं)।



क्लास टेम्पलेट के मुख्य भाग में, tfPtr "दो मापदंडों के साथ एक फ़ंक्शन के लिए पॉइंटर" और पॉइंटर fPtr स्वयं सेट हैं।



यदि कोई निर्दिष्ट है, तो डिफ़ॉल्ट निर्माणकर्ता एक अशक्त सूचक या विशिष्ट पता सेट करता है। इसके अलावा, पता अतिभारित ऑपरेटर = (शून्य * Ptr) के माध्यम से सेट किया जा सकता है। क्यों शून्य * - क्योंकि GetProcAddress () शून्य * ठीक देता है। हस्ताक्षर ऑपरेटर = (tfPtr Ptr) के साथ इसे ओवरलोड करने की आवश्यकता नहीं है - संकलक पहले से ही समझता है कि यह किस बारे में है।



ठीक है, अंत में, ओवरलोडिंग ऑपरेटर (), हम एक फ़नकार के रूप में वर्ग के उपयोग को प्राप्त करते हैं, और वर्ग उपयोगकर्ता के लिए - और आम तौर पर एक साधारण फ़ंक्शन कॉल।



क्या यह सुविधाजनक है? बहुत! देखें:

परिणाम

 #include < Windows.h > //  GetProcAdress #include < stdio.h > //  printf // ** // **     // ** #define FunctPtrExceptionType int //       #define FunctPtrExceptionDefValue 0 //     // ** // **      // ** template < typename Ret = void, typename Except = FunctPtrExceptionType, Except Value = FunctPtrExceptionDefValue > class Funct0 { public: typedef Ret (*tfPtr) (void); tfPtr fPtr; public: Funct0 (tfPtr Ptr = 0): fPtr (Ptr) {} Funct0 &operator= (tfPtr Ptr) { fPtr = Ptr; return this; } Ret operator () (void) throw (Except) { if (!fPtr) throw Except (Value); return fPtr (); } }; // ** // **     1  // ** template < typename Ret, typename Arg1, typename Except = FunctPtrExceptionType, Except Value = FunctPtrExceptionDefValue > class Funct1 { public: typedef Ret (*tfPtr) (Arg1); tfPtr fPtr; public: Funct1 (tfPtr Ptr = 0): fPtr (Ptr) {} Funct1 &operator= (void *Ptr) { fPtr = reinterpret_cast<tfPtr> (Ptr); return *this; } Ret operator () (Arg1 A1) throw (Except) { if (!fPtr) throw Except (Value); return fPtr (A1); } }; // ** // **     2  // ** template < typename Ret, typename Arg1, typename Arg2, typename Except = FunctPtrExceptionType, Except Value = FunctPtrExceptionDefValue > class Funct2 { public: typedef Ret (*tfPtr) (Arg1, Arg2); tfPtr fPtr; public: Funct2 (tfPtr Ptr = 0): fPtr (Ptr) {} Funct2 &operator= (void *Ptr) { fPtr = reinterpret_cast<tfPtr> (Ptr); return *this; } Ret operator () (Arg1 A1, Arg2 A2) throw (Except) { if (!fPtr) throw Except (Value); return fPtr (A1, A2); } }; // ** // **    // ** int add (const int A, const int *B) { int C; C = A + *B; printf (" int add (const int %d, const int %d) = %d\n", A, *B, C); return C; } void prn (void) { printf (" void prn (void)\n"); } // ** // **   // ** void main (void) { int i, i2; double d; long l; Funct0<> prner (prn); Funct1< double, long *, int, 2 > longer; Funct2< int, const int, const int * > adder; adder = add; longer = GetProcAddress (0, "Longer"); try { prner (); i2 = 6; i = adder (5, &i2); d = longer (&l); } catch (int val) { switch (val) { case 2: printf (" ***     !\n"); break; default: printf (" ***   !\n"); break; } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

परिणाम

रिलीज़ मोड में असंतुष्ट ने दिखाया कि इस तरह के फ़ंक्शन को कॉल करते समय ओवरहेड 0 वें मान की जाँच कर रहा है और इसलिए, एक और कॉल। मुझे लगता है कि आधुनिक पीसी के लिए यह कोई फर्क नहीं पड़ता।



पूर्णता के लिए, आप किसी भी तरह से अपवाद के विषय को परिष्कृत कर सकते हैं - पाठ स्ट्रिंग, अपनी स्वयं की कस्टम त्रुटि कक्षाएं आदि को पास करना अच्छा होगा, लेकिन आलस्य, मैं इसे लागू करने के लिए पैटर्न को अच्छी तरह से नहीं जानता।



ठीक है, निश्चित रूप से, आपको 3x, 4x, आदि तर्कों के लिए फ़ंक्शनल के विभिन्न वेरिएंट को रिवेट करना होगा। किसी तरह के मैक्रो के साथ आना अच्छा होगा जो उन्हें उत्पन्न करेगा ...



ठीक है, और इससे भी अधिक समझने वाली बात, आपको यह सब एक अलग .H फ़ाइल में रखने की आवश्यकता है।



मुझे उम्मीद है कि किसी ने समय बचाया। मैं रचनात्मक टिप्पणियों के लिए आभारी रहूंगा!



पुनश्च ऑपरेशन के दौरान, कॉल समझौते के रूप में ऐसी अप्रिय बात सामने आई थी। ऐसा लगता है कि आपको करने की आवश्यकता है Funct0Stdcall, Funct0Cdecl; Funct1Stdcall, Funct1Cdecl ...