如何在C ++中转储嵌套映射以进行调试？

如何解决如何在C ++中转储嵌套映射以进行调试？

| 为了调试，我需要转储嵌套映射的内容。我试图在下面的代码中对此进行描述：

struct Foo
{       
   string name;
};

typedef std::map<string,Foo> MapFoo;

struct Bar  {
  string name;    
  MapFoo mapFoo;
};

typedef std::map<string,Bar> MapBar;

...

MapBar mapBar = init_mapBar(); 

const MapBar::const_iterator it = mapBar.find(\"name\");

if ( mapBar.end() != it )
{
    return it->second;
}

在返回->秒之前，我想将该项目的内容转储到cout中。尝试执行此操作时，我迷失于迭代器。非常感谢您的帮助或提示。     

解决方法

        编写一个函数：

template <typename K,typename V,typename C>
void Dump( const map <K,V,C> & m ) {
    typename map <K,C>::const_iterator it = m.begin();
    while( it != m.end() ) {
        cout << it->first << \" = \" << it->second << endl;
        ++it;
    }
}

然后您可以说：

if ( mapBar.end() != it )
{
    Dump( it->second );
    return it->second;
}

并将其用于转储K和V是具有流运算符可用类型的任何其他地图。     ,        您可以使用两个单独的。一个代表3英镑，另一个代表4英镑。 例如，类似： 注意：我尚未测试代码。

map <string,map <string,int> > foo;
// fill map
map <string,int> >::iterator outerit;

map <string,int>::iterator innerit;

for (outerit = foo.begin(); outerit != foo.end(); ++outerit)
{
    for (innerit = outerit->second.begin(); innerit != outerit->second.end();++innerit)
    {
        cout << outerit->first << \" \" <<  innerit->first << \" \" << innerit->second << \"\\n\";
        //Write contents to a file here
    }
}

    ,        您可以在return语句之前添加它

std::cout << \"name: \" << it->second.name << std::endl;
MapFoo::const_iterator it2;
for (it2 = it->second.mapFoo.begin(); it2 != it->second.mapFoo.end(); ++it2)
  std::cout << it2->second.name << std::endl

    ,        如果您想完全避免任何编码而只需要一种快速且便宜的解决方案，则可以使用我们的魔术容器打印机-仅包含标头和宾果。 （如果您不在C ++ 0x中，则可能必须删除元组内容，并在尖括号之间放置一个空格。）     ,        我倾向于喜欢运算符重载。与某些“装饰器”配合使用时，效果非常好。 首先是范围适配器，我们将其用于任何容器

template <typename It>
struct Range
{
  Range(It b,It e): begin(b),end(e) {}
  It begin; It end;
};

template <typename It>
Range<It> MakeRange(It b,It e) { return Range<It>(b,e); }

template <typename C>
Range<typename C::const_iterator> MakeRange(C const& c) {
  return Range<typename C::const_iterator>(c.cbegin(),c.cend());
}

template <typename Stream,typename It>
Stream& operator<<(Stream& out,Range<It> range) {
  if (range.begin == range.end) { return out; }

  out << *range.begin;
  for (++range.begin; range.begin != range.end; ++range.begin) {
    out << *range.begin;
  }
  return out;
}

接下来是用于成对打印的装饰器（元组模式或词典模式）：

template <typename Stream>
class StreamPairDict
{
public:
  StreamPairDict(Stream& b): base(b) {}

  template <typename T,typename U>
  StreamPairDict& append(std::pair<T,U> const& p) {
    base << p.first << \": \" << p.second;
    return *this;
  }

  template <typename Other>
  StreamPairDict& append(Other const& o) {
    base << o; return *this;
  }

private:
  Stream& base;
};

template <typename S,typename T>
StreamPairDict<S>& operator<<(StreamPairDict<S>& stream,T const& t) {
  return s.append(t);
}

template <typename S,typename Stream>
StreamPairDict<S> MakeStreamPairDict(Stream& s) {
  return StreamPairDict<S>(s);
}

最后，是一个通用装饰器，可以在不侵犯

std

名称空间的情况下触发ADL：

template <typename S>
class Stream
{
public:
  typedef S Base;

  Stream(Base& b): base(b) {}

  template <typename T>
  Stream& append(T const& t) { base << t; return *this; }

private:
  Base& base;
};

template <typename S>
Stream<S>& operator<<(Stream<S>& s,bool b) { return s.append(b); }

template <typename S,typename Num>
typename std::enable_if< std::is_arithmetic<Num>::value,Stream<S>&>::type
operator<<(Stream<S>& s,Num n) { return s.append(n); }

template <typename S>
Stream<S>& operator<<(Stream<S>& s,char const* string) {
  return s.append(string);
}

template <typename S>
Stream<S>& operator<<(Stream<S>& s,std::string const& string) {
  return s.append(string);
}

/// many containers in the STL !!!
template <typename S,typename K,typename L,typename A>
Stream<S>& operator<<(Stream<S>& s,std::map<K,L,A> const& map) {
  return MakeStreamPairDict(s) << \'{\' << MakeRange(map) << \'}\';
}

template <typename S,std::multimap<K,typename H,std::unordered_map<K,H,std::unordered_multimap<K,A> const& map) {
  return MakeStreamPairDict(s) << \'{\' << MakeRange(map) << \'}\';
}

而且很容易使用：

int main() {
  std::map<int,std::map<char,Custom> > myMap;
  Stream(std::cout) << myMap << \'\\n\';
}

如果有

std::ostream& operator<<(std::ostream&,Custom const&)

，它将起作用。