重命名地图迭代器的第一个和第二个

Question

有没有办法重命名地图迭代器的第一个和第二个访问器函数。我知道它们具有这些名称是因为代表键和值的底层对，但我希望迭代器更具可读性。我认为使用迭代器适配器这可能是可能的，但我不确定如何实现它。

请注意，我无法使用 boost。

我的意思的例子：

map<Vertex, Edge> adjacency_list;
for(map<Vertex, Edge>::iterator it = adjacency_list.begin();
    it != adjacency_list.end();
    ++it)
{
    Vertex v = it->first;
    //instead I would like to have it->vertex
}

Answer 1

如果您只关心可读性，您可以这样做：

typedef map<Vertex, Edge> AdjacencyList;
struct adjacency
{
    adjacency(AdjacencyList::iterator& it) 
      : vertex(it->first), edge(it->second) {}
    Vertex& vertex;
    Edge& edge;
};

然后：

Vertex v = adjacency(it).vertex;

Answer 2

您无法重命名成员，但可以使用一些功能来提供帮助。

inline Vertex& vertex(map<Vertex, Edge>::iterator& it) {return it->first;}
inline Edge& edge(map<Vertex, Edge>::iterator& it) {return it->second;}

然后，您可以执行 vertex(it) ，而不是像您想要的那样 it->vertex

Answer 3

如果您不需要迭代器（例如，基于范围的 for 循环适合您的目的），那么从 c++17 开始，您可以使用结构化绑定：

map<Vertex, Edge> adjacency_list;
for( auto & [ vertex, edge ] : adjacency_list )
{
    // do stuff with vertex
}

Answer 4

不幸的是，没有。我通常做的是这样的：

typedef map<Vertex, Edge> AdjacencyList;
typedef AdjacencyList::value_type Vertex_Edge_Pair;

为了可读性。在你的循环中你也可以说

Vertex& current_vertex = it->first;
Edge& current_edge = it->second;

Answer 5

当然，重新实现或包装迭代器，但是值得付出努力吗？不是

Vertex& v = it->first;

更容易吗？

Answer 6

我不建议真正使用它，但它似乎确实有效，至少在测试程序执行我想要/期望的事情的最低程度上：

#include <map>
#include <string>
#include <iostream>

template <class T, class U>
struct my_pair : public std::pair<T, U> {
    T const &vertex;
    my_pair(std::pair<T, U> const &x) : std::pair<T, U>(x), vertex(x.first) { }
};

template <class T, class U>
struct my_map : public std::map<T, U> { 
    my_pair<T, U> find(T const &t) { return my_pair<T, U>(*std::map<T,U>::find(t)); }
};

class Vertex { 
    int x;
public:
    Vertex(int v) : x(v) {}
    bool operator<(Vertex const &other) const { return x < other.x; }
    friend std::ostream &operator<<(std::ostream &os, Vertex const &v) { return os << v.x; }
};

int main() { 
    my_map<Vertex, std::string> m;

    m[1] = "This is it";

    my_pair<Vertex, std::string> mp = m.find(1);
    std::cout << mp.vertex << ": " << mp.second;
    return 0;
}

Answer 7

我喜欢 KeithB 的具有免费功能的解决方案。然而，一个更可重用的解决方案可能会更好。

那么首先或第二访问的函数对象怎么样，因为您可以将实例命名为您喜欢的任何名称：

#include <map>
#include <string>
#include <iostream>

struct GetFirst
{
    template <class First, class Second>
    First& operator()(std::pair<First, Second>& p)
    {
        return p.first;
    }

    template <class First, class Second>
    const First& operator()(const std::pair<First, Second>& p)
    {
        return p.first;
    }
};

struct GetSecond
{
    template <class First, class Second>
    Second& operator()(std::pair<First, Second>& p)
    {
        return p.second;
    }

    template <class First, class Second>
    const Second& operator()(const std::pair<First, Second>& p)
    {
        return p.second;
    }
};

int main()
{
    typedef std::map<std::string, int> Map;

    Map persons;
    persons["John"] = 20;
    persons["Mary"] = 24;

    //create named accessors
    GetFirst name;
    GetSecond age;

    for (Map::iterator it = persons.begin(); it != persons.end(); ++it) {
        std::cout << name(*it) << " is aging.\n";
        ++age(*it);
    }

    for (Map::const_iterator it = persons.begin(); it != persons.end(); ++it) {
        std::cout << "Name: " << name(*it) << ", age: " << age(*it) << '\n';
    }
}

这是我能做的最好的事情。我还尝试让这些函子直接接受迭代器，但无论如何，这意味着签名将包含依赖名称，这显然使模板类型推导变得不可能（我找不到一种方法来重载迭代器的 GetSecond/ const_iterator 即使延迟返回类型为 C++0x）。

Answer 8

我有一个邪恶的解决办法！

#define vertex first
#define edge second

尽管作为一种邪恶的解决方案，当您在其他地方不小心使用这些词时，它无疑会造成巨大的创伤并且难以诊断编译问题。

添加是为了完整性。

不敢相信没有其他人提出这个建议。