आउटपुट इटरेटर के VALUE_TYPE

Question

एसटीएल आमतौर पर परिभाषित करता है तो जैसे एक निर्गम इटरेटर:

template<class Cont> 
class insert_iterator 
: public iterator<output_iterator_tag,void,void,void,void> { 
    // ... 

क्यों उत्पादन iterators value_typevoid के रूप में परिभाषित करते हैं? यह एल्गोरिदम के लिए उपयोगी होगा कि यह जानने के लिए कि किस प्रकार का मूल्य आउटपुट होना चाहिए।

उदाहरण के लिए, एक फ़ंक्शन जो यूआरएल क्वेरी "key1=value1&key2=value2&key3=value3" का अनुवाद किसी भी कंटेनर में करता है जिसमें कुंजी-मूल्य स्ट्रिंग तत्व होते हैं।

template<typename Ch,typename Tr,typename Out> 
void parse(const std::basic_string<Ch,Tr>& str, Out result) 
{ 
    std::basic_string<Ch,Tr> key, value; 
    // loop over str, parse into p ... 
     *result = typename iterator_traits<Out>::value_type(key, value); 
} 

SGI reference page of value_type संकेत यह है, क्योंकि यह एक आउटपुट इटरेटर भिन्नता के लिए संभव नहीं है। लेकिन उस value_type का ही उपयोग नहीं है: मैं आदेश इटरेटर निर्दिष्ट करने के लिए में एक दृष्टांत कर सकते हैं।

आउटपुट इटरेटर के साथ आउटपुट के लिए मूल्य बनाने के लिए क्या वैकल्पिक दृष्टिकोण है? दो दृष्टिकोण मैं माना:

• एक functor पैरामीटर है कि सही प्रकार का ऑब्जेक्ट वापसी होगी स्वीकार करें। मैं अभी भी एल्गोरिदम का एक संस्करण चाहता हूं जो उस फ़ंक्शन ऑब्जेक्ट पैरामीटर को नहीं लेता है।
• आवश्यकता होती है कि उत्पादन कंटेनर और कुछ एक प्रकार है कि से परिवर्तनीय pair<string,string> रखती है, या। मुझे आश्चर्य है कि मैं इस आवश्यकता के बिना कर सकता हूं, शायद किसी भी तत्व को दो std::string एस से बना सकता है।

Answer 1

इटरेटर का असली मूल्य प्रकार इटेटरेटर भी हो सकता है। operator* आसानी से सिर्फ इसलिए कि असली काम असाइनमेंट ऑपरेटर द्वारा किया जाता है *this के लिए एक संदर्भ वापस आ सकते हैं। आपको अच्छी तरह से पता चल सकता है कि *it = x; और it = x; आउटपुट इटरेटर्स के साथ बिल्कुल वही प्रभाव पड़ता है (मुझे लगता है कि बाद वाले को संकलित करने से रोकने के लिए विशेष उपाय किए जा सकते हैं)।

इस तरह, वास्तविक मूल्य प्रकार को परिभाषित करना उतना ही बेकार होगा। एक void के रूप में यह परिभाषित करना दूसरी तरफ, की तरह त्रुटियों को रोकने के कर सकते हैं:

typename Iter::value_type v = *it; //useless with an output iterator if it compiled 

मुझे लगता है यह सिर्फ उत्पादन iterators की अवधारणा की सीमा है: वे जिन वस्तुओं पर "दुरुपयोग" ऑपरेटर ओवरलोडिंग कर रहे हैं, के रूप में तो पॉइंटर जैसा दिखता है, जबकि वास्तव में कुछ पूरी तरह से अलग हो रहा है।

आपकी समस्या दिलचस्प है, हालांकि।आप किसी भी कंटेनर का समर्थन करना चाहते हैं, तो सवाल में उत्पादन iterators शायद std::insert_iterator, std::front_insert_iterator और std::back_insert_iterator होगा। इस मामले में आप निम्नलिखित की तरह कुछ कर सकता है:

#include <iterator> 
#include <vector> 
#include <string> 
#include <map> 
#include <iostream> 

//Iterator has value_type, use it 
template <class T, class IterValue> 
struct value_type 
{ 
    typedef IterValue type; 
}; 

//output iterator, use the container's value_type 
template <class Container> 
struct value_type<Container, void> 
{ 
    typedef typename Container::value_type type; 
}; 

template <class T, class Out> 
void parse_aux(Out out) 
{ 
    *out = typename value_type<T, typename Out::value_type>::type("a", "b"); 
} 

template <template <class> class Out, class T> 
void parse(Out<T> out) 
{ 
    parse_aux<T>(out); 
} 

//variadic template in C++0x could take care of this and other overloads that might be needed 
template <template <class, class> class Out, class T, class U> 
void parse(Out<T, U> out) 
{ 
    parse_aux<T>(out); 
} 

int main() 
{ 
    std::vector<std::pair<std::string, std::string> > vec; 
    parse(std::back_inserter(vec)); 
    std::cout << vec[0].first << ' ' << vec[0].second << '\n'; 

    std::map<std::string, std::string> map; 
    parse(std::inserter(map, map.end())); 
    std::cout << map["a"] << '\n'; 

    //just might also support normal iterators 
    std::vector<std::pair<std::string, std::string> > vec2(1); 
    parse(vec2.begin()); 
    std::cout << vec2[0].first << ' ' << vec2[0].second << '\n'; 
} 

यह अभी भी सिर्फ तुम इतनी दूर मिलेगा। मुझे लगता है कि कोई इसे आगे ले सकता है, इसलिए यह std::ostream_iterator<printable_type> का प्रबंधन भी कर सकता है, लेकिन किसी बिंदु पर यह इतना जटिल हो जाएगा कि त्रुटि संदेश को समझने के लिए भगवान को ले जाता है, कुछ गलत होना चाहिए।

Answer 2

एक पुनरावर्तक के value_type का उद्देश्य उस प्रकार को परिभाषित करना है जब उस इटरेटर को संदर्भित किया जाता है। *output_iterator = value के रूप में - उत्पादन iterators के लिए, भिन्नता ऑपरेटर का केवल वैध का उपयोग जब यह असाइनमेंट ऑपरेटर के साथ संयोजन के रूप में इस्तेमाल किया जाता है। आउटपुट इटरेटर को डिफ्रेंस करते समय लौटाया जाने वाला प्रकार आवश्यक रूप से उन प्रकारों के साथ कोई सीधा संबंध नहीं रखता है जिन्हें आउटपुट इटरेटर के माध्यम से संग्रहीत किया जा सकता है। एकमात्र आवश्यक रिश्ते यह है कि बाद के प्रकार को पूर्व प्रकार के लिए असाइन करने का कोई तरीका है।

इसके अलावा, आउटपुट इटरेटर कई प्रकार के मानों को स्टोर कर सकता है, और इन प्रकारों को एक दूसरे के साथ कोई संबंध नहीं होना चाहिए। उदाहरण null_output_iteratorDiscarding the output of a function that needs an output iterator में वर्णित के लिए ले लो। यह इटरेटर किसी भी प्रकार के मूल्य भंडारण के लिए स्वीकार कर सकता है।