C++ Re：使用boost:：make_transform_迭代器进行引用访问

我试图使用boost:：make_transform_迭代器为自定义类创建迭代器，该类的数据保存在映射中，迭代器使用键向量访问值

在我的问题中，映射的值是包含大量数据的容器。因为我无法复制数据，所以我希望通过迭代器通过引用访问数据。但是，在执行此操作时，数据会被破坏，正如我所附的简单示例的输出所示

据我所知，问题在于使用from_key functor（使用对映射的引用初始化）和boost:：make_transform_迭代器的语义

你知道我如何使用boost正确地完成这项工作吗

谢谢

帕特里克

#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;
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
使用名称空间boost:：assign；
名称空间bl=boost:：lambda；
阶级持有者
{
公众：
holder（）：v（）{}；
holder（const std:：vector&in）：v（in）{}；
std:：vector&vector（）{return v；}；
const std:：vector&vector（）常量{return v；}；
私人：
std：：向量v；
};
从_键初始化
{
公众：
typedef-holder-result_-type；
from_key（const boost:：无序的_map&m）：map_u（m）{}；
const holder&operator（）（const std:：string&in）const{return map_uu.at（in）；}；
私人：
常量boost：：无序映射&map；
};
typedef boost:：transform_迭代器迭代器；
int main（）
{
向量键；
按键+=“1”、“2”、“3”；
std：：向量VAL；
VAL+=1.0,2.0,3.0；
保持架h（VAL）；
boost：：无序映射m；
插入（m）（“1”，h）
（“2”，h）
（“3”，h）；
iterator it=boost:：make_transform_iterator（keys.begin（），from_key（m））；
迭代器end=boost:：make_transform_迭代器（keys.begin（），from_key（m））；
const std:：vector&v=it->vector（）；
std:：for_each（vals.begin（），vals.end（）），std:：cout这只是我的猜测，但transform_迭代器是函数对象和基迭代器的包装器。如果其解引用运算符的返回类型与函子的result_类型的typedef相同，我不会感到惊讶。您尝试过将引用类型用作result_type-typedef吗

换句话说，改变

typedef holder result_type;

到

看看会发生什么

typedef holder const& result_type;