आउटपुट इटरेटर एडाप्टर गिनने के लिए, लेकिन प्रतिलिपि

Question

कई एसटीएल एल्गोरिदम हैं जो एल्गोरिदम के परिणाम को स्टोर करने के लिए आउटपुट इटरेटर पर भरोसा करते हैं।

उदाहरण के लिए, std::set_intersection आउटपुट इटरेटर में दो क्रमबद्ध श्रेणियों के बीच सभी सामान्य तत्वों को संग्रहीत करेगा जो उसके बाद आउटपुट प्रति तत्व बढ़ाए गए हैं।

कभी-कभी, मुझे वास्तविक तत्वों में रुचि नहीं है बल्कि केवल आउटपुट तत्वों की संख्या है। ऐसे मामलों में यह तत्वों की प्रतिलिपि बनाने के लिए स्मृति और प्रदर्शन का अपशिष्ट है। क्या कोई इटरेटर एडाप्टर है जिसका उपयोग मैं तत्वों की प्रति को गिनने और उससे बचने के लिए कर सकता हूं? यदि आप ऐसा एडाप्टर का सामान्य कार्यान्वयन नहीं कर सकते हैं?

Answer 1

@ecatmur जवाब और टिप्पणियों से मदद का एक बहुत कुछ करने के लिए धन्यवाद, मैं निम्नलिखित समाधान है, जो मैं टिप्पणियां आमंत्रित करे। मुझे boost::make_function_output_iterator काम करने की उम्मीद थी लेकिन ऐसा लगता है कि लाइब्रेरी में एक बग है जो असाइनमेंट ऑपरेटर को परिभाषित करने में विफल रहता है।

#include <algorithm> 
#include <vector> 
#include <iostream> 
#include <string> 
#include <cassert> 

class counting_output_iterator 
{ 
public: 
    counting_output_iterator& operator=(const counting_output_iterator&) { return *this; }; 
    explicit counting_output_iterator(std::size_t& count) : m_count(count) {} 
    template<typename T> void operator=(const T&) {}; //NULL op 
    using iterator_category = std::output_iterator_tag; 
    using value_type = void; 
    using difference_type = void; 
    using pointer = void; 
    using reference = void;  
    counting_output_iterator& operator*() { return *this; } 
    counting_output_iterator& operator++() { ++m_count; return *this; } 
    std::size_t& m_count; 
}; 

int main(int, char*[]) 
{ 
    std::vector<int> arr{ 1,2,3,4 }; 
    std::size_t count = 0; 
    std::copy(std::begin(arr), std::end(arr), counting_output_iterator{ count }); 
    assert(count == 4u); 
    return 0; 
} 

Answer 2

बूस्ट के Function Output Iterator आप क्या चाहते हैं कर सकते हैं:

std::size_t count = 0u; 
int arr[]{0, 1, 2, 3}; 
std::copy(std::begin(arr), std::end(arr), 
    boost::make_function_output_iterator([&](auto const&) { ++count; })); 
assert(count == 4u); 

केवल मुद्दा आप इटरेटर बाहर गिनती चर घोषित करने के लिए है कि है, कोई रास्ता नहीं एक boost::function_output_iterator से संग्रहीत समारोह वस्तु को निकालने के लिए है, क्योंकि (और लैम्बडा से बंद मूल्यों को निकालने का कोई भी तरीका नहीं है, भले ही आप उस बाधा से पहले हो)। यदि आप एक-लाइनर लिखने में सक्षम होना चाहते हैं, तो आपको इसे इटरेटर क्लास लिखना होगा, लेकिन यह कोड की एक बड़ी मात्रा नहीं है; उदाहरण के लिए:

class counting_output_iterator { 
public: 
    using iterator_category = std::output_iterator_tag; 
    using value_type = void; 
    using difference_type = void; 
    using pointer = void; 
    using reference = void; 

    std::size_t value = 0u; 

    struct output_proxy { 
    output_proxy(std::size_t& value) : m_value(value) { } 
    template<class T> output_proxy& operator=(T const&) { 
     ++m_value; 
     return *this; 
    } 
    std::size_t& m_value; 
    }; 
    output_proxy operator*() { return output_proxy(value); } 
    counting_output_iterator& operator++() { return *this; } 
    counting_output_iterator& operator++(int) { return *this; } 
}; 

उपयोग:

int arr[]{0, 1, 2, 3}; 
auto const count = std::copy(std::begin(arr), std::end(arr), 
    counting_output_iterator{}).value; 
assert(count == 4u);