how to build a tree structure in C++ using std::map - c++

Question

I am trying to write a tree sort of structure in C++. As in every tree there are branches and leaves. A branch can contain other branches as well as leaves.
Now my implementation calls for each branch and leaf to have different functionalities. So for example.
Take the tree structure
Root
| |
Branch1 Branch2 Branch3
| | |
Leaf1 Leaf2 Branch4
Now Each Leaf and branch has a different function to execute so Leaf1 will have a function called leaf1_func, Leaf2 will have leaf2_func, Branch4 has Branch4_func.
I was initially trying to implement composite design pattern. But that means I would have as many classes as leafs. But since I have tons of leaves and branches I would like to avoid creates more classes. I realize this is an unusual situation but was hoping somebody could help me in this regard. What would be the best way to implement this tree without creating too many classes.
i am using map STL container to store datas as well, i want to use this tree implementation to solve this in TSP problem.
#include <cstdlib>
#include <iostream>
#include <map>
using namespace std;
int n=4;
int min=1, max=10;
struct graph
{
int nodes;//total no. of nodes or vertices namely cities
std::map<std::pair<int,int>, int> graphMap;//an object that links a pair of vertices
};
void directed_Graph(graph);
void directed_Graph(graph G)
{
//int n = G->nodes; //city count
int i, j;
for(i = 0; i <= n-1; i++)
{
for(j = 0; j <= n-1; j++)
{
if(i!=j)
{
G.graphMap[std::make_pair(i,j)] = (rand()%10)+1;
//cout<<G.graphMap[std::make_pair(i,j)]<<"\n";
}
else
{
G.graphMap[std::make_pair(i,j)] = 0;
}
}
}
}
int main(int argc, char** argv)
{
graph g;
g.nodes = 4;
directed_Graph(g);
return 0;
}

Answer 1

Different functions with the same signature do still have the same type. Even if the functions are completely unrelated, you can have a tree that stores random data by using void * (type erasure) and then typecast back to the known actual type after the leaf node is reached.
struct node {
void (*fptr)(); // pointer to any function taking no args, no return
void *data; // pointer to anything, need to cast before using
};
void f() { std::cout << "hello"; }
void g() { std::cout << "world"; }
node a = { f, f };
node b = { g, g };
a.fptr();
static_cast< void (*)() >( b.data )();
You could also use virtual methods with inheritance and store pointers to base class type in the tree. It depends on what the nodes really are.
None of this is really related to the fact it goes into a graph.

Answer 2

From the look of you diagram it seems that you want a tree where the nodes can have more than two children. If that's the case then the STL containers are not going to work for you. They are are self balancing binary trees.
If you're OK with a binary tree then there are a couple ways to do this. The first is to write functions and then to store function pointers or functors in the tree.
#include <set>
int foo( ) {
return 5;
}
std::set< int (*)( ) > my_set;
my_set.insert( &foo );
The problem with this approach is that all of your functions have to have the same type, i.e. take the same arguments and have the same return type. What's more, while they can define different behaviors, they cannot keep state, i.e. you cannot store data in a function pointer.
The second options, as you mentioned, is to write classes. If you need to vary the behavior of the nodes then the best way to do that is to define an interface and use polymorphism.
#include <set>
#include <iostream>
struct base {
virtual void print( ) const = 0;
};
struct derived1 : public base {
void print( ) const { std::cout << "derived1" << std::endl; }
};
struct derived2 : public base {
void print( ) const { std::cout << "derived2" << std::endl; }
};
std::set< base* > my_set;
my_set.insert( new derived1( ));
my_set.insert( new derived2( ));
You did not say whether you need to force certain behaviors to be leaves and other to be internal nodes, or if the nodes need to be ordered in a particular way, but if you do then you may be able to accomplish this by creating a custom less-than function:
bool operator < ( base const * const b1, base const * const b2 ) {
// Figure out which is less here.
}
Again, if you need something that isn't a binary tree, though, then you're out of luck. And any way you slice this you will need to write some code implementing the behavior stored in each node, whether it's functions or classes.

Answer 3

if you have limited depth of tree it's convenient to describe it like this:
typedef std::map<std::string, double> action_map_t;
typedef std::map<std::string, action_map_t> objid_map_t;
typedef std::map<std::string, objid_map_t> objtype_map_t;
//....etc here is depth == 3
objtype_map_t m_mapTooltipDuration;
m_mapTooltipDuration[objtype][objid][action] = atof(duration.c_str());