c++ - Binding a templated standard library function -

आप ऐसा कैसे करते हैं? वैकल्पिक को लम्बाडा या std :: function में std :: generate रैपिंग की आवश्यकता होती है और यह अवांछनीय है।

  int main () {using सरणी_इन = std :: सरणी & lt; int, 10 & gt ;; std :: वेक्टर & LT; array_int & gt; vec (10); Std :: for_each (vec.begin (), vec.end (), std :: bind (std :: generate, std :: placeholders :: _ 1, [] () {वापसी 0;})); वापसी 0; }   
 जैसा कि समस्या यह है कि  std :: generate  एक इटरेटर जोड़ी लेता है। चलो बहाना वे इसके बजाय बढ़ावा पर्वत हैं:  
  बढ़ावा :: for_each (vec, बढ़ावा :: बाँध (बढ़ावा :: उत्पन्न, _1, [] () {वापसी 0;}));    
 
 
 मुझे लगता है कि आप वास्तव में  उत्पन्न करने के लिए कुछ अधिक उपयोगी हैं , क्योंकि उन सरणियों को पहले से ही शून्य से भर दिया जाएगा, क्योंकि  वेक्टर  मूल्य उन्हें आरम्भ करता है।  
 आपकी बाँध अभिव्यक्ति सही कोड की संख्या को  जेनरेट करें , इसलिए निर्दिष्ट करें कि  जेनरेट करें  को आप चाहते हैं कि केवल एकमात्र समस्या नहीं है स्पेशलाइजेशन के लिए आपको जेनरेटर के प्रकार को जानना होगा जिसे आप पास करना चाहते हैं, जो लैंबडा है, इसलिए आपको इसे बाहर ले जाना चाहिए:  
  auto gen = [] {return 0; };   
 फिर आपको यह कहना होगा कि आप कौन सी  जेनरेट करें  चाहते हैं:  
  std :: generate & lt; array_int :: iterator, decltype ( जनरल) & gt;   
 तब आपको इसके लिए सही तर्क देना होगा:  
  std :: bind (std :: generate & lt; array_int :: iterator, decltype (gen) ) & Gt ;, std :: bind (& amp; array_int :: begin, std :: placeholders :: _ 1), std :: bind (& array_int :: end, std :: placeholders :: _ 1), जनरल));   
 यह अभी भी काम नहीं करेगा, क्योंकि  array_int :: begin  और  array_int :: end  अतिभारित है, इसलिए आपको डालने की आवश्यकता है गैर कोडित संस्करण प्राप्त करने के लिए उन्हें  array_int :: iterator (array_int :: *) ()   
  ऑटो जन = [] {वापसी 0; }; Memfunc = array_int :: iterator का उपयोग कर (array_int :: *) () ;; Std :: bind (std :: generate & lt; array_int :: iterator, decltype (gen) & gt;, std :: bind ((memfunc) & amp; array_int :: begin, std :: placeholders :: _ 1), std :: bind ((Memfunc) & amp; सरणी_इन :: अंत, std :: प्लेसहोल्डर्स :: _ 1), जनरल));   
 आप  gener_n  के साथ थोड़ा सा सरल बना सकते हैं क्योंकि आप आकार जानते हैं, और शायद  डेटा ()  के बजाय < कोड> आरंभ () , हालांकि आपको इसे डालने की आवश्यकता है:  
  ऑटो जन = [] {वापसी 0; }; Memfunc = int * (array_int :: *) () ;; Std :: bind (std :: generate_n & lt; int *, int, decltype (gen) & gt;, std :: bind ((memfunc) और सरणी_इन :: डेटा, std :: placeholders :: _ 1), 10, जनरल) );   
 या आप सिर्फ लैम्ब्डा का उपयोग कर सकते हैं:  
  std :: for_each (vec.begin (), vec.end (), [] (सरणी_आईटी & amp; ; ए) {std :: उत्पन्न (a.begin (), a.end (), [] {वापसी 0;})}};   
 यदि आप  boost :: generate  पर कॉल करना चाहते हैं, तो इसके बजाय यह थोड़ा आसान है क्योंकि आपको नेस्टेड बाँध अभिव्यक्ति की आवश्यकता नहीं है, लेकिन आपको अभी भी प्रकार की आवश्यकता है जनरेटर:  <पूर्व>  ऑटो जन = [] {वापसी 0; }; Std :: bind (boost :: generate & lt; array_int, decltype (gen) & gt ;, std :: placeholders :: _ 1 जनरल);   
 या एक लैम्ब्डा के साथ:  
  std :: for_each (vec.begin (), vec.end (), [] (सर_आर्ट और एक) {Boost :: उत्पन्न (ए, [] {वापसी 0;})}};