पुन: boost :: make_transform_iterator

Question

के साथ संदर्भ पहुंच मैं कस्टम श्रेणी के लिए एक इटरेटर बनाने के लिए boost :: make_transform_iterator का उपयोग करने का प्रयास कर रहा हूं जिसका डेटा मानचित्र में रखा गया है और जहां इटरेटर मूल्यों तक पहुंचने के लिए कुंजी के वेक्टर का उपयोग करता है ।

मेरी समस्या में, मानचित्र के मान कंटेनर हैं जिनमें बड़े डेटा होते हैं। चूंकि मैं डेटा कॉपी करने का जोखिम नहीं उठा सकता, इसलिए मैं डेटारेटर के माध्यम से संदर्भ द्वारा डेटा तक पहुंचना चाहता हूं। हालांकि, ऐसा करने पर, डेटा दूषित हो जाता है, जैसा कि मैंने संलग्न सरल उदाहरण के आउटपुट द्वारा उदाहरण दिया है।

जहां तक ​​मैं कह सकता हूं, समस्या से_की मज़ेदार के उपयोग में निहित है, जिसे मानचित्र के संदर्भ का उपयोग करके शुरू किया गया है, और boost :: make_transform_iterator के अर्थशास्त्र।

कोई विचार है कि मैं इसे बढ़ावा देने के तरीके से कैसे ठीक से कर सकता हूं?

धन्यवाद,

पैट्रिक

#include <iostream> 
#include <string> 
#include <vector> 

#include <boost/unordered_map.hpp> 
#include <boost/iterator/transform_iterator.hpp> 
#include <boost/assign.hpp> 
#include <boost/assign/std/vector.hpp> 
#include <boost/lambda/lambda.hpp> 
#include <boost/lambda/bind.hpp> 
#include <boost/ref.hpp> 

using namespace boost::assign; 
namespace bl = boost::lambda; 

class holder 
{ 
    public: 
     holder() : v() {}; 
     holder(const std::vector<double>& in) : v(in) {}; 

     std::vector<double>& vector()    { return v; }; 
     const std::vector<double>& vector() const { return v; }; 

    private: 
     std::vector<double> v; 
}; 

class from_key 
{ 
    public: 

     typedef holder result_type; 

     from_key(const boost::unordered_map<std::string, holder >& m) : map_(m) {}; 

     const holder& operator() (const std::string& in) const { return map_.at(in); }; 

    private: 
     const boost::unordered_map<std::string, holder >& map_; 
}; 

typedef boost::transform_iterator<from_key, std::vector<std::string>::iterator > iterator; 

int main() 
{ 
    std::vector<std::string> keys; 
    keys += "1","2","3"; 

    std::vector<double> vals; 
    vals += 1.0, 2.0, 3.0; 
    holder h(vals); 

    boost::unordered_map<std::string, holder > m; 
    insert(m) ("1", h) 
       ("2", h) 
       ("3", h); 

    iterator it = boost::make_transform_iterator(keys.begin(), from_key(m)); 
    iterator end = boost::make_transform_iterator(keys.begin(), from_key(m)); 

    const std::vector<double>& v = it->vector(); 

    std::for_each(vals.begin(), vals.end(), std::cout << bl::_1 << " "); 
    std::cout << std::endl; 
    std::for_each(v.begin(), v.end(), std::cout << bl::_1 << " "); 
    std::cout << std::endl; 
} 

Answer 1

यह मैं सिर्फ अनुमान लगा है, लेकिन transform_iterator समारोह वस्तु और आधार इटरेटर के चारों ओर एक आवरण है। अगर आपका ड्रेफरेंस ऑपरेटर का रिटर्न टाइप आपके मज़ेदार के परिणाम_ प्रकार के लिए टाइपपीफ जैसा ही होता है तो मुझे surprized नहीं किया जाएगा। क्या आपने result_type-typedef के रूप में संदर्भ प्रकार का उपयोग करने का प्रयास किया है?

दूसरे शब्दों में

typedef holder result_type; 

बदलने

typedef holder const& result_type; 

लिए और देखो क्या होता ...