इस तथ्य के आसपास कैसे काम करें कि std :: function में कोई ऑपरेटर == नहीं है?

Question

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

यह संकलित नहीं करता है क्योंकि आप ऑपरेटर ==() के साथ std :: फ़ंक्शन इंस्टेंस की तुलना नहीं कर सकते हैं। और std :: find() ठीक उसी तरह करने की कोशिश करता है।

बेशक, मैं पूरी तरह से कार्यान्वयन के लिए जा सकता हूं, लेकिन जैसा कि मैं नीचे हूं और जैसा कि मैं नीचे कोड के साथ हूं, मैं जिद्दी हूं, मैं कुछ "निकटतम संभव" ढूंढ रहा हूं जो काम करता है।

कौन मुझे नीचे दिए गए कोड का एक सुंदर पुनर्लेख प्रदान कर सकता है जो वही काम करता है?

#include <functional> 
#include <vector> 

typedef std::function<bool(int)> Tester_t; 
typedef std::vector<Tester_t> TesterSet_t; 

bool Test(TesterSet_t &candidates, int foo) 
{ 
    TesterSet_t dropouts; 
    for(auto& tester : candidates) 
    { 
     if(!tester(foo))  
     { 
      droputs.push_back(tester); 
     } 
    } 

    while(!dropouts.empty()) 
    { 
     // The following line is not compiling because std::function has no operator==() 
     TesterSet_t::iterator culprit = 
      std::find(candidates.begin(), candidates.end(), dropouts.back()); 
     candidates.erase(culprit); 
     dropouts.pop_back(); 
    } 
    return !candidates.empty(); 
} 

Answer 1

हटाने की जरूरत है, तो आप इसके लिए std::function एस की तुलना की आवश्यकता नहीं है। मानक सी ++ इस सुविधा का उपयोग कुशलता से (रेखीय जटिलता के साथ) दो पंक्तियों में लागू किया जा सकता है:

bool Test(TesterSet_t &candidates, int foo) 
{ 
    candidates.erase(std::remove_if(candidates.begin(), candidates.end(), 
     [foo](Tester_t& f){ return !f(foo); }), candidates.end()); 
    return !candidates.empty(); 
} 

Answer 2

आपको यहां समानता की आवश्यकता नहीं है। के रूप में तुम जाओ

for (auto it = candidates.begin(); it != candidates.end();) { 
    if (! (*it)(foo)) { 
     it = candidates.erase(it); 
    } 
    else { 
     ++it; 
    } 
} 
return !candidates.empty(); 

यह भी सवाल भले ही operator==std::function के लिए परिभाषित किया गया था में संस्करण की तुलना में तेजी हो हो जाएगा बस मिटा।

Answer 3

क्या तुमने कभी न उम्मीदवारों को मिटाने के लिए की जरूरत है आप लिख सकते हैं:

bool Test(TesterSet_t &candidates, int foo) 
{ 
    return std::any_of(candidates.begin(), candidates.end(), [&foo](Tester_t &tester) { 
     return tester(foo); 
    }); 
} 

अद्यतन

ठीक है, आप के रूप में अन्य लोगों ने कहा उम्मीदवारों

bool Test(TesterSet_t &candidates, int foo) 
{ 
    candidates.erase(
     std::remove_if(candidates.begin(), candidates.end(), [&foo](Tester_t &tester) { 
      return !tester(foo); 
     }), 
     candidates.end() 
    ); 
    return !candidates.empty(); 
} 

Answer 4

सरल जवाब इस मामले में std::function<...> बल्कि std::function<...> की तरह कुछ है जो एक समानता ऑपरेटरों को परिभाषित करता है का उपयोग नहींहै। function<...> के लिए एक समानता ऑपरेटर को परिभाषित करने का दृष्टिकोण निर्माण पर पता लगाने के लिए है कि वास्तविक फ़ंक्शन ऑब्जेक्ट में वास्तव में एक समानता ऑपरेटर होता है और यदि ऐसा है, तो वस्तु को तुलनीय बना दें। अन्यथा, आप या तो एक त्रुटि उत्पन्न करेंगे या आप इस विशेष कार्य ऑब्जेक्ट प्रकार को अतुलनीय होने के लिए ऑब्जेक्ट्स पर विचार करेंगे।

तत्काल अवलोकन, हालांकि, अधिकांश फ़ंक्शन ऑब्जेक्ट तुलनीय नहीं हैं! उदाहरण के लिए, लैम्ब्डा फ़ंक्शंस तुलनीय नहीं हैं और std::bind() और std::mem_fn() तुलनात्मक फ़ंक्शन ऑब्जेक्ट्स भी नहीं देते हैं। फिर, std::bind() और std::mem_fn() के लिए एक कस्टम कार्यान्वयन हो सकता है। लैम्ब्डा कार्यों को तुलनीय बनाने के लिए कोई रास्ता नहीं है जब तक में रिक्त कैप्चर होता है, तो उस स्थिति में उन्हें फ़ंक्शन पॉइंटर्स में बदल दिया जा सकता है और इसकी तुलना की जा सकती है।

समानता-जागरूक फ़ंक्शन ऑब्जेक्ट्स का कार्यान्वयन थोड़ा प्रतिक्रिया देने के लिए थोड़ा लंबा है। हालांकि, आप समानता-तुलनीय bind() और mem_fn() के लिए github पर मेरे कार्यान्वयन पर एक नज़र डाल सकते हैं। std::function<...> की समानता तुलनीय संस्करण के कार्यान्वयन के लिए this answer देखें। लैम्बडा फ़ंक्शंस तुलनीय होने के लिए वांछनीय हो सकता है, अगर उनके पास समान हस्ताक्षर हैं और सभी कैप्चर किए गए मान समानता तुलनीय हैं।

सभी ने कहा कि, यदि आप आवश्यकता से बच सकते हैं, तो शायद यह सबसे अच्छा बचा है। हालांकि, मैं कुछ उपयोग मामलों में आया हूं जहां तुलनात्मक std::function<...> इसके प्रतिबंधों के बावजूद आसान होगा (यानी, सभी फ़ंक्शन ऑब्जेक्ट्स को कवर नहीं किया जाएगा)।