矢量地图的地图如何通过地图的地图进行迭代

Question

我试图在C ++中没有7个循环的情况下从矢量地图的地图的地图的地图的地图中收集所有数据。

数据外观如下：

Map 1=>Map 1.1=>Map 1.1.1=>Map 1.1.2=>Map 1.1.3=>Map 1.1.4=>Vector 1.1.5=>Elem 1
                                                                        =>Elem 2
       Map 1.2=>Map 1.2.1=>Map 1.2.2=>Map 1.2.3=>Map 1.2.4=>Vector 1.2.5=> Elem 1
                                                                        =>Elem 2
Map 2 =>Map 1.1=>Map 1.1.1=>Map 1.1.2=>Map 1.1.3=>Map 1.1.4=>Vector 1.1.5=>Elem 1
                                                                         =>Elem 2
        Map 1.2=>Map 1.2.1=>Map 1.2.2=>Map 1.2.3=>Map 1.2.4=>Vector 1.2.5=>Elem 1
                                                                         =>Elem 2

因此，我试图将所有地图中的所有Elem 1，Elem 2收集到一张地图中。

有人可以帮我做这个，而不是通过每个映射进行明显的循环并在C ++中导致7个循环吗？

谢谢您的帮助。

Answer 1

我喜欢@inflagranti的想法-因此，在不要求实用程序的情况下，这是一个遍历所有内容的for-each模板。 它使用了漂亮打印机的is_container特性，在此不做复制。

更新：现在完全解决了裸值类型和对值类型的问题。

更新2：感谢@Luc Danton，简化了实现类。

#include <algorithm>

#include "prettyprint.hpp"    
using namespace pretty_print;  // for "is_container" trait

template <typename T> struct is_pair : public std::false_type { };
template <typename S, typename T> struct is_pair<std::pair<S,T>> : public std::true_type { };

template <typename T> struct final_value { typedef T type; };
template <typename S, typename T> struct final_value<std::pair<S,T>> { typedef T type; };

template <typename Iter, typename F> void for_each_recursive(Iter begin, Iter end, F f);

template <typename F, bool Recurse> struct for_each_rec_impl;

template <typename F>
struct for_each_rec_impl<F, false>
{
  template <typename Iter>
  static typename std::enable_if<is_pair<typename std::iterator_traits<Iter>::value_type>::value, void>::type
  go(Iter begin, Iter end, F f)
  {
    for (Iter it = begin; it != end; ++it) f(it->second);
  }

  template <typename Iter>
  static typename std::enable_if<!is_pair<typename std::iterator_traits<Iter>::value_type>::value, void>::type
  go(Iter begin, Iter end, F f)
  {
    for (Iter it = begin; it != end; ++it) f(*it);
  }
};

template <typename F>
struct for_each_rec_impl<F, true>
{
  template <typename Iter>
  static typename std::enable_if<is_pair<typename std::iterator_traits<Iter>::value_type>::value, void>::type
  go(Iter begin, Iter end, F f)
  {
    for (Iter it = begin; it != end; ++it)
      {
        for_each_recursive(it->second.begin(), it->second.end(), f);
      }
  }

  template <typename Iter>
  static typename std::enable_if<!is_pair<typename std::iterator_traits<Iter>::value_type>::value, void>::type
  go(Iter begin, Iter end, F f)
  {
    for (Iter it = begin; it != end; ++it)
      {
        for_each_recursive(it->begin(), it->end(), f);
      }
  }
};

template <typename Iter, typename F>
void for_each_recursive(Iter begin, Iter end, F f)
{
  typedef typename std::iterator_traits<Iter>::value_type value_type;
  typedef typename final_value<value_type>::type type;

  for_each_rec_impl<F, is_container<type>::value>::go(begin, end, f);
}

用法： for_each_recursive(v.begin(), v.end(), my_predicate<final_value_type>);

Answer 2

除非更改数据类型，否则您可能会陷入循环内循环的困境。

但是，我将从将.. vector的地图的地图重写为1个vector的地图开始。 我建议使用boost :: tuple或std :: tuple（C ++ 0x）创建类，但是您也可以定义自己的类，并重载运operator <以便将其用作映射键（或编写比较器）

使用boost :: tuple，如果您有map<Key1, map< Key2, map<Key3, map<Key4, map<Key5, map<Key6, vector<T> > > > > > >可以将其重新map<Key1, map< Key2, map<Key3, map<Key4, map<Key5, map<Key6, vector<T> > > > > > >为map< boost::tuple< Key1, Key2, Key3, Key4, Key5, Key6 >, vector<T> > 。

Answer 3

如果确实需要，则可以执行一些模板元编程（例如，使用boost mpl），以抽象出循环。 但是，正如许多人所建议的那样，比起需要7个嵌套映射和一个矢量的解决方案，有一种更好的解决方案。