将指针值类型为的无序映射上的迭代器转换为常量引用值类型的同一映射上的迭代器

如果boost迭代器的使用不是强制性的，那么您可以编写自己的迭代器。我正在发布一个，它满足ForwardIterator。您可以简单地将其扩展到BidirectionalIterator（不过，它可能有点乏味）。

在发布之前，恐怕我无法满足您的要求（除了使用boost迭代器）；使用std::pair<char, const Node*>而不是std::pair<char, const Node&>，因为后者禁止复制。也许这就是阻止您编译boost::transform_iterator示例的原因（我不确定；我对boost迭代器不太熟悉）。

无论如何，这是code.cpp（125行）。包含main测试功能：

#include <unordered_map>
#include <memory>
class Node;
template <class Map>
class MyIterator {
public:
    // iterator member typedefs
    using iterator_category = std::forward_iterator_tag;
    using value_type = std::pair<char, const Node*>;
    using difference_type = std::ptrdiff_t;
    using pointer = value_type*;
    using reference = value_type&;
    // typedef for underlying iterator
    using underlying_iterator = typename Map::const_iterator;
    // constructors
    // takes an underlying iterator
    explicit MyIterator(underlying_iterator it) : _it(std::move(it)) {}
    // default constructor; required by ForwardIterator
    MyIterator() = default;
    // dereference; required by InputIterator
    reference operator*() {
        update();
        return _p;
    }
    // dereference; required by InputIterator
    pointer operator->() {
        update();
        return &_p;
    }
    // increment; required by Iterator
    MyIterator<Map>& operator++() {
        ++_it;
        return *this;
    }
    // increment; required by InputIterator
    MyIterator<Map> operator++(int) {
        auto mit = *this;
        ++*this;
        return mit;
    }
    // comparison; required by EqualityComparable
    bool operator==(const MyIterator<Map>& mit) const {
        return _it == mit._it;
    }
    // comparison; required by InputIterator
    bool operator!=(const MyIterator<Map>& mit) const {
        return !(*this == mit);
    }
private:
    // this method must be called at dereference-time but not
    // traverse-time in order to prevent UB at a wrong time.
    void update() {
        _p = value_type{_it->first, &*(_it->second)};
    }
    // the underlying iterator that tracks the map
    underlying_iterator _it;
    // the pair of the desired type. without it, e.g. operator-> doesn't
    // work; it has to return a pointer, and the pointed must not be a
    // temporary object.
    value_type _p;
};
class Node {
public:
    typedef std::unique_ptr<Node> ptr_type;
    typedef std::unordered_map<char, ptr_type> map_type;
    typedef MyIterator<map_type> const_iterator;
    const_iterator begin() const {
        return const_iterator{_children.begin()};
    }
    const_iterator end() const {
        return const_iterator{_children.end()};
    }
private:
    map_type _children;
// additional members for testing purposes.
public:
    Node(std::string name) : _name(std::move(name)) {}
    Node(std::string name, map_type&& children) :
        _children(std::move(children)), _name(std::move(name)) {}
    std::string const& name() const {
        return _name;
    }
private:
    std::string _name;
};
#include <iostream>
// test program; construct a simple tree and print children.
int main() {
    typedef std::unique_ptr<Node> ptr_type;
    typedef std::unordered_map<char, ptr_type> map_type;
    ptr_type leaf1(new Node("leaf1"));
    ptr_type leaf2(new Node("leaf2"));
    ptr_type leaf3(new Node("leaf3"));
    map_type branch;
    branch.emplace('1', std::move(leaf1));
    branch.emplace('2', std::move(leaf2));
    branch.emplace('3', std::move(leaf3));
    Node parent("parent", std::move(branch));
    for (auto it = parent.begin(); it != parent.end(); ++it) {
        std::cout << it->first << ' ' << it->second->name() << 'n';
    }
    return 0;
};

编译命令：

g++ -std=c++11 -g -O2 -Wall code.cpp

我的输出：

3 leaf3
2 leaf2
1 leaf1

MyIterator是作为模板类编写的，因此当您想将std::unordered_map更改为例如std::map时，不需要修改MyIterator；）

使事情复杂化的是operator*必须返回对std::pair的引用；这意味着某个地方必须存在std::pair的（非临时）对象，否则该引用将成为悬空引用。与operator->相同（将"reference"替换为"pointer"）。

这里，MyIterator::_p是参考的std::pair。这是在更新时分配的副本，而std::pair<char, const Node&>（包含引用的对）禁止这样做。

std::pair<char, const Node&>的替代品是std::pair<char, const Node*>或std::pair<char, std::reference_wrapper<const Node>>。如果选择使用std::reference_wrapper替代方案，请将it->second->name()替换为it->second.get().name()。

我认为这可能是boost::indirect_iterator存在的原因。从（琐碎的）map<char, char *>:上的boost文档中改编一个示例

#include <iostream>
#include <map>
#include <boost/iterator/indirect_iterator.hpp>

int main() {
    char characters[] = "abcdefg";
    size_t ncharacters = sizeof characters - 1;
    char *charptr[ncharacters];
    for (size_t i = 0; i < ncharacters; ++i) {
        charptr[i] = &characters[i];
    }
    std::map <char, char *> map1;
    for (size_t i = 0; i < ncharacters; ++i) {
        map1[characters[i]] = charptr[i]; /* Trivial, just to demonstrate */
    }
    boost::indirect_iterator<char * const*, char const> const_indirect_first(charptr),
                                                        const_indirect_last(charptr + ncharacters);
    std::copy(const_indirect_first, const_indirect_last, std::ostream_iterator<char>(std::cout, " "));
    std::cout << std::endl;
    return 0;
}