अगर कॉन्स्टेक्सप्रांड की अनुमति नहीं है तो sfinae क्यों है?

Question

का पता लगाने के रूप में मुहावरा

template<typename T, typename = void> 
struct has_foo {static constexpr bool value = false;}; 
template<typename T> 
struct has_foo<T, std::void_t<decltype(&T::foo)>> {static constexpr bool value = true;}; 
template<typename T> 
constexpr bool has_foo_v = has_foo<T>::value; 

इस प्रकार है और फिर हम किसी भी प्रकार T में foo की उपस्थिति का पता लगाने कर सकते हैं काम करता है।

if constexpr(has_foo_v<decltype(var)>) 
    var.foo(); 

मेरे समस्या है, कि टाइप करने के लिए काफी एक बहुत (पढ़ें: अभाव अपने कीबोर्ड एक बहुत टाइप करने के लिए नष्ट करने के लिए) है, और मैं अगर निम्न संभव है

if constexpr(std::void_t<decltype(&decltype(var)::foo)>(), true) 
    var.foo(); 

ऐसा नहीं है सोचा ।

क्या इसके पीछे कोई कारण है?
अधिक विशेष रूप से, यदि इस अनुमति की अनुमति दी गई तो क्या व्यापार-बंद किए जाने होंगे?

Answer 1

सदस्य कार्य करने के लिए सूचक का आपके द्वारा उपयोग एक बुरा विचार है, यदि foo ओवरलोड हो गया है, तो यह बहुत खराब हो जाता है (आपके पास एक foo है, लेकिन केवल एक नहीं)। वास्तव में कौन चाहता है "क्या आपके पास बिल्कुल एक फू है"? लगभग कोई नहीं।

यहाँ एक briefer संस्करण है:

template<class T> 
using dot_foo_r = decltype(std::declval<T>().foo()); 

template<class T> 
using can_foo = can_apply<dot_foo_r, T>; 

जहां

namespace details { 
    template<template<class...>class, class, class...> 
    struct can_apply:std::false_type{}; 
    template<template<class...>class Z, class...Ts> 
    struct can_apply<Z, std::void_t<Z<Ts...>>, Ts...>:std::true_type{}; 
} 
template<template<class...>class Z, class...Ts> 
using can_apply = details::can_apply<Z, void, Ts...>; 

अब, लेखन dot_foo_r थोड़ा कष्टप्रद है।

constexpr लैम्बडास के साथ हम इसे कम परेशान कर सकते हैं और इसे इनलाइन कर सकते हैं।

#define RETURNS(...) \ 
    noexcept(noexcept(__VA_ARGS__)) \ 
    -> decltype(__VA_ARGS__) \ 
    { return __VA_ARGS__; } 

यह जरूरत RETURNS मैक्रो, कम से कम जब तक @[](auto&&f)RETURNS(f()) को बैरी प्रस्तुत [](auto&&f)=>f() के बराबर हो नहीं करता है।

हम तो can_invoke_f, जो std::is_invokable के constexpr संस्करण है लिखें:

template<class F> 
constexpr auto can_invoke(F&& f) { 
    return [](auto&&...args)->std::is_invokable<F(decltype(args)...)>{ 
    return {}; 
    }; 
} 

यह हमें देता है:

if constexpr(
    can_invoke([](auto&&var) RETURNS(var.foo()))(var) 
) { 
    var.foo(); 
} 

या का उपयोग करते हुए @ बैरी प्रस्तावित सी ++ 20 वाक्य रचना:

if constexpr(can_invoke(var=>var.foo())(var)) { 
    var.foo(); 
} 

और हम कर रहे हैं।

चाल यह है कि RETURNS मैक्रो (या => सी ++ 20 फीचर) हमें अभिव्यक्ति पर SFINAE करने देता है। लैम्ब्डा उस अभिव्यक्ति को मूल्य के रूप में ले जाने का एक आसान तरीका बन जाता है।

आप

[](auto&&var) ->decltype(var.foo()) { return var.foo(); } 

लिख सकता है लेकिन मुझे लगता है RETURNS इसके लायक है (और मैं मैक्रो पसंद नहीं है)।

Answer 2

के बाद से ग यदि आप वास्तव में sfinae इनलाइन करने की ज़रूरत ++ 17 वहाँ हमेशा एक constexpr लैम्ब्डा समाधान नहीं है:

#include <utility> 

template <class Lambda, class... Ts> 
constexpr auto test_sfinae(Lambda lambda, Ts&&...) 
    -> decltype(lambda(std::declval<Ts>()...), bool{}) { return true; } 
constexpr bool test_sfinae(...) { return false; } 

template <class T> 
constexpr bool bar(T var) { 
    if constexpr(test_sfinae([](auto v) -> decltype(v.foo()){}, var)) 
     return true; 
    return false; 
} 

struct A { 
    void foo() {} 
}; 

struct B { }; 

int main() { 
    static_assert(bar(A{})); 
    static_assert(!bar(B{})); 
} 

[live demo]

Answer 3

आप std::is_detected का उपयोग कर कोड की मात्रा को भी कम कर सकते हैं।

अपने उदाहरण में, कोड तो लगेगा जैसे:

template <class T> 
using has_foo_t = decltype(std::declval<T>().foo()); 

if constexpr(std::is_detected_v<has_foo_t,decltype(var)>) 
    var.foo();