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

How to dump nested maps in C++ for debugging purposes?

本文关键字：映射 调试 嵌套 转储 C++      更新时间：2023-10-16

为了调试，我需要转储嵌套映射的内容。我试图用下面的代码来描述这一点：

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。尝试这样做时，我对迭代器迷路了。非常感谢您的帮助或提示。

你可以使用两个单独的。一个用于map <string, int>，一个用于map<string, map<string, int> >.

例如，类似这样的内容：
注意：我还没有测试代码。

map <string, map <string, int> > foo;
// fill map
map <string, 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
    }
}

编写一个函数：

template <typename K, typename V, typename C>
void Dump( const map <K,V,C> & m ) {
    typename map <K,V,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 是具有可用流运算符的类型。

您可以在 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 V, typename L, typename A>
Stream<S>& operator<<(Stream<S>& s, std::map<K,V,L,A> const& map) {
  return MakeStreamPairDict(s) << '{' << MakeRange(map) << '}';
}
template <typename S, typename K, typename V, typename L, typename A>
Stream<S>& operator<<(Stream<S>& s, std::multimap<K,V,L,A> const& map) {
  return MakeStreamPairDict(s) << '{' << MakeRange(map) << '}';
}
template <typename S, typename K, typename V, typename H, typename A>
Stream<S>& operator<<(Stream<S>& s, std::unordered_map<K,V,H,A> const& map) {
  return MakeStreamPairDict(s) << '{' << MakeRange(map) << '}';
}
template <typename S, typename K, typename V, typename H, typename A>
Stream<S>& operator<<(Stream<S>& s, std::unordered_multimap<K,V,H,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&)将起作用.

相关文章：