कोई std :: सुरक्षा क्यों नहीं है?

Question

क्यों सी ++ 11 में std::bind के साथ एक साथ उपयोग करने के लिए कोई std::protect है?

Boost.Bind एक boost::protect सहायक है कि इसके तर्क लपेटता ताकि boost::bind को नहीं पहचानता है और यह मूल्यांकन प्रदान करता है। std::[c]ref एक अच्छा पर्याप्त प्रतिस्थापन, समय की सबसे हो सिवाय इसके कि यह एक rvalue तर्क के रूप में नहीं ले जाएगा होगा।

एक ठोस उदाहरण के लिए, निम्नलिखित कृत्रिम स्थिति पर विचार:

#include <type_traits> 
#include <functional> 

int add(int a, int b) 
{ return a + b; } 

struct invoke_with_42 
{ 
    template <typename FunObj> 
    auto operator()(FunObj&& fun_obj) const -> decltype((fun_obj(42))) 
    { return fun_obj(42); } 
}; 

int main() 
{ 
    //// Nested bind expression evaluated 
    //auto bind_expr = 
    // std::bind<int>(invoke_with_42{} 
    //  , std::bind(&add, 1, std::placeholders::_1)); 

    //// Compilation error, cref does not take rvalues 
    //auto bind_expr = 
    // std::bind<int>(invoke_with_42{} 
    //  , std::cref(std::bind(&add, 1, std::placeholders::_1))); 

    //// Ok, inner_bind_expr must be kept alive 
    auto inner_bind_expr = 
     std::bind(&add, 1, std::placeholders::_1); 
    auto outer_bind_expr = 
     std::bind<int>(invoke_with_42{}, std::cref(inner_bind_expr)); 


    //// Ok, with protect 
    //auto bind_expr = 
    // std::bind<int>(invoke_with_42{} 
    //  , std::protect(std::bind(&add, 1, std::placeholders::_1))); 
} 

Answer 1

ठीक है, मैं क्यों यह लागू नहीं किया गया के बारे में पता नहीं कर रहा हूँ। शायद यह प्रस्तावित नहीं किया गया था, या शायद कुछ सूक्ष्म गठिया थे।

कहा, मुझे लगता है आप बहुत आसानी से

template<typename T> 
struct protect_wrapper : T 
{ 
    protect_wrapper(const T& t) : T(t) 
    { 

    } 

    protect_wrapper(T&& t) : T(std::move(t)) 
    { 

    } 
}; 

template<typename T> 
typename std::enable_if< !std::is_bind_expression< typename std::decay<T>::type >::value, 
       T&& >::type 
protect(T&& t) 
{ 
    return std::forward<T>(t); 
} 

template<typename T> 
typename std::enable_if< std::is_bind_expression< typename std::decay<T>::type >::value, 
       protect_wrapper<typename std::decay<T>::type > >::type 
protect(T&& t) 
{ 
    return protect_wrapper<typename std::decay<T>::type >(std::forward<T>(t)); 
} 

रक्षित के दो संस्करणों ताकि गैर बाँध भाव लिपटे नहीं कर रहे हैं (वे सिर्फ माध्यम से पारित) कर रहे हैं यह लिख सकते हैं। बाकी सब कुछ protect_wrapper पर स्थानांतरित/प्रतिलिपि द्वारा पारित किया जाता है, जो कि इस प्रकार से प्राप्त होता है। यह प्रकार के कार्यों को पार करने की अनुमति देता है, या इसके लिए प्रकार में कनवर्ट करने की अनुमति देता है।

यह एक कॉपी/तथापि के लिए कदम बनाता है, इसलिए इसे सुरक्षित रूप से rvals के साथ प्रयोग किया जा सकता है। और चूंकि यह केवल उन प्रकारों की सुरक्षा करता है जो bind_expressions हैं, यह प्रतिलिपि बनाने की मात्रा को कम करता है।

int main() 
{ 

    //// Ok, with protect 
    auto bind_expr = 
     std::bind<int>(invoke_with_42{} 
      , protect(std::bind(&add, 1, std::placeholders::_1))); 


    std:: cout << bind_expr() << std::endl; 
    return 0; 

}