कंपाइल-टाइम पर जांचें यदि टेम्पलेट तर्क शून्य है

Question

मैं विंडोज़ एपीआई फ़ंक्शंस को लपेटने की कोशिश कर रहा हूं ताकि त्रुटियों की जांच हो सके। जैसा कि मैंने पिछले SO प्रश्न में पाया है, मैं एपीआई फ़ंक्शन को कॉल करने के लिए टेम्पलेट फ़ंक्शन का उपयोग कर सकता हूं, और फिर सेट किए गए किसी भी त्रुटि को पुनर्प्राप्त करने के लिए GetLastError() पर कॉल कर सकता हूं। मैं इस त्रुटि को अपने Error कक्षा में भेज सकता हूं ताकि मुझे इसके बारे में जानकारी मिल सके। का प्रयोग के रूप में यह अद्भुत काम करता है

int WINAPI someFunc (int param1, BOOL param2); //body not accessible 

int main() 
{ 
    int ret = someFunc (5, true); //works normally 
    int ret2 = Wrap (someFunc, 5, true); //same as above, but I'll get a message if there's an error 
} 

इस प्रकार यह मैं कोड हो सकता है

template<typename TRet, typename... TArgs> 
TRet Wrap(TRet(WINAPI *api)(TArgs...), TArgs... args) 
{ 
    TRet ret = api(args...); 
    //check for errors 
    return ret; 
} 

:

यहाँ टेम्पलेट समारोह के लिए कोड है। हालांकि, एक संभावित समस्या है। समारोह

void WINAPI someFunc(); 

ले लो जब टेम्पलेट समारोह में इस subbing, यह इस प्रकार है:

void Wrap(void(WINAPI *api)()) 
{ 
    void ret = api(); //<-- ahem! Can't declare a variable of type void... 
    //check for errors 
    return ret; //<-- Can't return a value for void either 
} 

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

कि एक तरफ, मैं

if (strcmp (typeid (TRet).name(), "v") != 0) //typeid(void).name() == "v" 
{ 
    //do stuff with variable to return 
} 

else 
{ 
    //do stuff without returning anything 
} 

का उपयोग कर फिर भी कोशिश की, typeid एक क्रम तुलना है, इसलिए कोड अभी भी वजह से एक शून्य चर घोषित करने के लिए कोशिश कर रहा करने के लिए संकलन नहीं करता है, भले ही यह कभी नहीं होगा।

अगला, मैंने typeid के बजाय std::is_same <TRet, void>::value का उपयोग करने का प्रयास किया, लेकिन पता चला कि यह रनटाइम तुलना भी था।

इस बिंदु पर, मुझे नहीं पता कि आगे क्या प्रयास करना है। क्या संकलक को विश्वास करने की कोई संभावना है कि मुझे पता है कि मैं क्या कर रहा हूं ठीक है? मुझे Wrap पर एक अतिरिक्त तर्क संलग्न करने में कोई फर्क नहीं पड़ता, लेकिन मैं वास्तव में उसमें से कुछ भी प्राप्त नहीं कर सका।

मैं जीएनयू जी ++ 4.6.1, और विंडोज एक्सपी, साथ ही विंडोज 7 के साथ कोड :: ब्लॉक का उपयोग करता हूं। किसी भी मदद के लिए धन्यवाद, भले ही यह मुझे बता रहा हो कि मुझे केवल Wrap का उपयोग नहीं करना पड़ेगा शून्य के लिए काम करने वाले कार्यों के लिए।

Answer 1

आप ठीक धुन विशेषज्ञताओं को एक सहायक वर्ग का उपयोग कर सकते हैं:

template <typename F> 
struct wrapper 
{}; 

template <typename Res, typename... Args> 
struct wrapper<Res(Args...)> 
{ 
    static Res wrap(Res (WINAPI *f)(Args...), Args&& args...) 
    { 
     Res r = f(std::forward<Args>(args)...); 
     // Blah blah 
     return r; 
    } 
}; 

template <typename... Args> 
struct wrapper<void(Args...)> 
{ 
    static void wrap(void (WINAPI *f)(Args...), Args&& args...) 
    { 
     f(std::forward<Args>(args)...); 
     // Blah blah 
    } 
}; 

अब, आप आवरण लिख सकते हैं:

template <typename Res, typename... Args> 
Res Wrap(Res (WINAPI *f)(Args...), Args&& args...) 
{ 
    return wrapper<Res(Args...)>::wrap(f, std::forward<Args>(args)...); 
} 

ध्यान दें कि यह और भी काम करता है जब Resvoid है। आपको return को फ़ंक्शन लौटने वाले शून्य में एक अभिव्यक्ति लौटने की अनुमति है।

सही प्रकार को Wrap(someFunc, 5, true) में, शून्य लौटने वाले फ़ंक्शंस के लिए भी कम किया जाता है।

Answer 2

टिप्पणी से बढ़ावा देना समझने मैं क्यों शून्य के रूप में वापसी प्रकार विशेषज्ञता काम नहीं किया (वापसी प्रकार पर स्पष्ट करने नहीं कर सकता है), लेकिन शून्य के साथ विशेषज्ञता जवाब देने के लिए और जोड़ने एक अतिरिक्त पैरामीटर काम करना चाहिए, क्या हुआ? आपको स्पष्ट प्रकारों के साथ आना पड़ सकता है।

Answer 3

इस के आसपास जाने के लिए, मैंने टेम्पलेट का एक संस्करण बनाने का प्रयास किया जहां मैंने ट्रेट को शून्य से बदल दिया। दुर्भाग्यवश, यह वास्तव में केवल एक अस्पष्टता का कारण बनता है जिसका उपयोग करना है।

कि चाहिए काम करते हैं, मुझे विश्वास है, क्योंकि voidTRet की तुलना में अधिक विशिष्ट है, लेकिन जैसा कि आप बाहर बिंदु यह नहीं है। मुझे कुछ याद आ रहा है, लेकिन किसी भी दर पर, इससे कोई फर्क नहीं पड़ता, आप TRet ओवरलोड को चुनने से रोक सकते हैं।

template<typename TFun, typename... TArgs> 
auto Wrap(TFun api, TArgs&&... args) -> 
typename std::enable_if< 
    !std::is_void<typename std::result_of<TFun(TArgs...)>::type>::value, 
    typename std::result_of<TFun(TArgs...)>::type 
>::type 
{ 
    auto result = api(std::forward<TArgs&&>(args)...); 
    return result; 
} 

template<typename TFun, typename... TArgs> 
auto Wrap(TFun api, TArgs&&... args) -> 
typename std::enable_if< 
    std::is_void<typename std::result_of<TFun(TArgs...)>::type>::value, 
    typename std::result_of<TFun(TArgs...)>::type 
>::type 
{ 
    api(std::forward<TArgs&&>(args)...); 
} 

void WINAPI f1() 
{ 
} 

void WINAPI f2(double) 
{ 
} 

int WINAPI f3() 
{ 
    return 0; 
} 

int WINAPI f4(double) 
{ 
    return 0; 
} 

int main() { 
    Wrap(f1); 
    Wrap(f2, 0); 
    return Wrap(f3) * Wrap(f4, 0); 
} 

अद्यतन: पैरामीटर प्रकार के तर्क प्रकार से रूपांतरण के लिए अनुमति देने के लिए समायोजित।