C++: Nested map - c++

Question

Here is the definition:
struct nmap;
struct nmap: map<string, boost::variant<string, nmap*>>{};
The last line below doesn't work:
nmap my_map;
my_map["a"] = "b";
my_map["c"] = new nmap;
my_map["c"]["d"] = "e";
What do I need to add, in order for this to work?

Answer 1

I'd suggest either going for a tiny little readable helper:
#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";
}
Or go the recursive variant way. Let me sketch:
Recursive Variant Trees
This is IMO more elegant:
#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;
}
At first glance this may look more complicated, but it actually has a number of important advantages:
no more inheriting from classes not intended for inheritance
no more limitation that the 'root' object /must/ be a map (it can be a string too now, so the variant is more consistently honoured)
no more memory leaks Due to the fact that the variant now actually takes care of allocating the actual nmap instances, there's full value-semantics out of the box.
allows for idiomatic visiting of the tree, no need for 'ifs and buts dereferences', e.g. consider how we could do a quick & dirty implementation of that 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;
}
See it Live On coliru
Output:
# g++ -std=c++11 -Wall -pedantic -Wextra main.cpp && ./a.out
{
a: b
c: {
d: e
f: {
empty: {}
most nested: leaf node
}
}
}