C++ 如何在container'；什么东西？

比如说，我有一个类，里面有

std:：list

；我如何为这个类实现迭代器，使它能够遍历这个列表中包含的字符串

或者，例如，在我的类中，我有一个向量

struct

s，其中包含

a

、

b

和

c

；我可以创建一个迭代器（可能继承vector的迭代器？不知道），当取消引用时，它将返回一个

std:：pair

，对应于

（b，c）

我所说的迭代器是指类似于

std:：vector

的迭代器的东西：我可以通过

which.begin（）

获得它，并像前面提到的那样，对列表中的字符串进行迭代

UPD好的，这是我想要的更多信息。在我的

HashMap

类中，我有

项

：一个

结构的列表

：每个结构都有一个键、一个值和一个指向它在表中位置的指针。我需要的是一个迭代器；但这不是通过执行

items.begin（）

可以得到的，因为这个迭代器在取消引用时将返回我的结构。我需要一个迭代器，这样当用户调用

HashMap.begin（）

时我就可以返回它，它应该解引用到一个

std:：pair

，对应于（key，value）

希望这能让我的问题更清楚

UPD2 这是我的

结构

，如果有帮助的话：

template<class KeyType, class ValueType>
struct node {
    KeyType key;
    ValueType value;
    node** place;

    node(KeyType key_ = KeyType(), ValueType value_ = ValueType()): key(key_), value(value_) {};
};

模板
结构节点{
键型键；
值类型值；
节点**位置；
节点（KeyType key=KeyType（），ValueType value=ValueType（））：key（key），value（value）{}；
};

一种优雅的方法是使用转换迭代器或转换范围：

#include <iostream>
#include <list>
#include <boost/range/adaptor/transformed.hpp>
#include <boost/iterator/transform_iterator.hpp>

int main() {
    std::list<std::pair<int, std::string>> l;
    auto extractor = [](auto&& elem) { return elem.second; };

    // Using a transformed range.
    for(auto&& v: l | boost::adaptors::transformed(extractor))
        std::cout << v << '\n';

    // Using transform iterators.
    for(auto i = boost::make_transform_iterator(l.begin(), extractor), j = boost::make_transform_iterator(l.end(), extractor); i != j; ++i)
        std::cout << *i << '\n';
}

#包括
#包括
#包括
#包括
int main（）{
std：：列表l；
自动提取器=[]（自动和元素）{return elem.second；}；
//使用变换范围。
用于（自动和自动：l |增压：：适配器：：转换（提取器））
STD:：CUT不能用于任意结构的解构。这需要运行时的反射，这在C++中是不可用的。您可以为每个具体结构提供您自己的迭代器实现，在这里您需要使用它。在这样做时可能是有用的。要重复列表中的字符串或其他什么吗？哟。你应该解释为什么你需要这样的迭代器，因为可能有其他的方法来做。@Galik确切地说，是的，但你仍然可以使用列表迭代器访问列表中的
std:：string
实例，并执行
it->second
操作，除非我完全误解了这个问题。好吧，我很确定我不允许d使用
boost
等等，所以…虽然这很好，但没有帮助me@Akiiino如果不能重用boost，那么可以重用底层思想：为容器制作迭代器类模板，一个模板参数是transform函数/提取器对象类型。
struct MyContianer
{
    std::list<std::pair<int, std::string>> container;

    static auto constexpr first_extractor = [](auto&& elem) { return elem.second; };
    using iterator_first = decltype(boost::make_transform_iterator(container.begin(), first_extractor));
    iterator_first begin_first() { return {container.begin(), first_extractor}; }
    iterator_first end_first() { return {container.end(), first_extractor}; }

    static auto constexpr second_extractor = [](auto&& elem) { return elem.second; };
    using iterator_second = decltype(boost::make_transform_iterator(container.begin(), second_extractor));
    iterator_second begin_second() { return {container.begin(), second_extractor}; }
    iterator_second end_second() { return {container.end(), second_extractor}; }

};
decltype(MyContianer::first_extractor) constexpr MyContianer::first_extractor;
decltype(MyContianer::second_extractor) constexpr MyContianer::second_extractor;

int main() {
    MyContianer c;
    c.begin_first();
    c.begin_second();
}