C++: вложенная карта

Я бы предложил либо использовать крошечного читаемого помощника:

#include <boost/variant.hpp>
#include <map>

using std::map;

struct nmap;
struct nmap: map<std::string, boost::variant<std::string, nmap*>>
{
    typedef boost::variant<std::string, nmap*> Variant;
    typedef map<std::string, Variant> base;

    friend nmap&       as_map(Variant& v)       { return *boost::get<nmap*>(v); }
    friend nmap const& as_map(Variant const& v) { return *boost::get<nmap*>(v); }

    friend std::string&       as_string(Variant& v)       { return boost::get<std::string>(v); }
    friend std::string const& as_string(Variant const& v) { return boost::get<std::string>(v); }
};

int main()
{
    nmap my_map;
    my_map["a"] = "b";
    my_map["c"] =  new nmap;

    as_map(my_map["c"])["d"] = "e";
}

Или пойти по пути рекурсивного варианта. Позвольте мне набросать:

Рекурсивные деревья вариантов

Это ИМО более элегантно:

#include <boost/variant.hpp>
#include <map>

using nmap  = boost::make_recursive_variant<std::string, std::map<std::string, boost::recursive_variant_> >::type;
using map_t = std::map<std::string, nmap>;

#include <iostream>
static std::ostream& operator<<(std::ostream& os, nmap const& map);

int main()
{
    nmap my_map = map_t
    {
        { "a", "b" },
        { "c", map_t
            {
                { "d", "e" },
                { "f", map_t
                    {
                        { "most nested", "leaf node" },
                        { "empty", map_t { } },
                    } },
            } },
        };

    std::cout << my_map;
}

На первый взгляд это может показаться более сложным, но на самом деле имеет ряд важных преимуществ:

• больше не наследоваться от классов, не предназначенных для наследования
• больше нет ограничения на то, что «корневой» объект /должен/ быть картой (теперь он может быть и строкой, поэтому этот вариант более последовательно соблюдается)
• утечек памяти больше нет Из-за того, что вариант теперь фактически заботится о выделении фактических nmap экземпляров, полная семантика значений предустановлена.

• позволяет идиоматическое посещение дерева, нет необходимости в разыменовании ifs и buts, например подумайте, как мы могли бы сделать быструю и грязную реализацию этого operator<<:

  static std::ostream& operator<<(std::ostream& os, nmap const& map)
  {
      struct print : boost::static_visitor<void>
      {
          print(std::ostream& os, int indent = 0) : os(os), indent(indent) { }
  
          void operator()(map_t const& map) const {
              os << "{";
              for(auto& item : map)
              {
                  os << "\n";
                  do_indent();
                  os << "    " << item.first << ": ";
                  boost::apply_visitor(print(os, indent+4), item.second);
              }
              if (!map.empty()) { os << "\n"; do_indent(); };
              os << "}";
          }
  
          void operator()(std::string const& str) const {
              os << str;
          }
  
      private:
          std::ostream& os;
          void do_indent() const { for (int n = indent; n>0; --n) os << ' '; }
          int indent = 0;
      };
  
      boost::apply_visitor(print(os), map);
      return os;
  }
  

Смотрите на coliru

Выход:

# g++ -std=c++11 -Wall -pedantic -Wextra main.cpp  && ./a.out

{
    a: b
    c: {
        d: e
        f: {
            empty: {}
            most nested: leaf node
        }
    }
}