Re: accesso di riferimento con boost :: make_transform_iterator

Question

Sto provando a utilizzare boost :: make_transform_iterator per creare un iteratore per una classe personalizzata i cui dati sono contenuti in una mappa e dove l'iteratore utilizza il vettore di chiavi per accedere ai valori .

Nel mio problema, i valori della mappa sono contenitori che contengono dati di grandi dimensioni. Dato che non posso permettermi di copiare i dati, vorrei accedere ai dati per riferimento tramite l'iteratore. Tuttavia, quando si esegue questa operazione, i dati sono danneggiati, come è esemplificato dall'output del semplice esempio che ho allegato.

Per quanto posso dire, il problema sta nell'uso del functor from_key, che viene inizializzato usando un riferimento alla mappa e la semantica di boost :: make_transform_iterator.

Qualche idea su come potrei farlo correttamente usando boost?

Grazie,

Patrick

#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

Questo sono io solo indovinare, ma transform_iterator è un wrapper per l'oggetto funzione e l'iteratore base. Non sarei sorpreso se il tipo di ritorno dell'operatore di dereferenziazione è uguale al typedef per result_type del tuo functor. Hai provato a utilizzare un tipo di riferimento come result_type-typedef?

In altre parole cambiano

typedef holder result_type; 

a

typedef holder const& result_type; 

e vediamo cosa succede ...