std::map<long, boost::any>

class ISimpleElement
{
    //...
};

class SimpleElementA : public ISimpleElement
{
    //...
};

class SimpleElementB : public ISimpleElement
{
    //...
};

class IContainer
{
    //...
};

class Container1 : public IContainer
{
    // ...
};

class Container2 : public IContainer
{
    // ...
};


int main()
{
    Container1 cont1;
    Container2 cont2;
    cont1.add(0, new SimpleElementA);
    cont1.add(1, new SimpleElementB);
    SimpleElementA* A = cont1.get<SimpleElementA>(0); // возвращает указатель на элемент нужного типа
    SimpleElementA* A1 = cont1.get<SimpleElementA>(1); // кидает эксепшн, что типа не соответствует типу хранимого элемента
    SimpleElementA* A2 = cont1.get<SimpleElementA>(3); // кидает эксепшн, элемента с таким id нет в контейнере

    cont2.add(2, new SimpleElementA);
    cont2.add(3, new SimpleElementB);
    cont2.add(4, &cont1); // еще не определился что будут передаваться указатели, скорее всего будут смарт поинтеры, но сейчас это не важно - просто пример

    SimpleElementA* A3 = cont2.get<SimpleElementA>(0); // ищет сначала внутри себя, а потом в других контейнерах внутри себя, когда находит - возвращает, не находит - кидает эксепшн
    Container1* p_cont1 = cont2.get<Container1>(4); // возвращает контейнер
}

typedef ISimpleElement Leaf;
struct Container;

typedef shared_ptr<Leaf> LeafPtr;
typedef shared_ptr<Container> ContainerPtr;

struct Container
{
  typedef variant<LeafPtr, ContainerPtr> Node;
  typedef map<long, Node> Table;
  Table items;
};

pair<ContainerPtr, LeafPtr> findById(ContainerPtr root, long id)
// возвращает лист и его непосредственного хозяина
{
  Table::const_iterator it = root->items.find(id);
  if(it != root->items.end())
  {
    if(LeafPtr* leaf = it->get<LeafPtr>())
      return make_pair(root, *leaf);
    //иначе - под этим id'ом таится контейнер...
  }

  for(it = root->items.begin(); it != root->items.end(); ++it)
  {
    if(ContainerPtr* cont = it->get<ContainerPtr>()) // нас интересуют только контейнеры
    {
      pair<ContainerPtr, LeafPtr> found = findById(*cont, id);
      if(found.first)
        return found;
    }
  }

  return make_pair(ContainerPtr(),LeafPtr());
}

pair<ContainerPtr, LeafPtr> found = findById(*cont, id);
if(found.first)
  found.first->items.erase(id);

shared_ptr<Base> pb;
....
if(pb->IsMyTypeFoo())
{
  shared_ptr<Foo> pf = static_pointer_cast<Foo>(pb);
  ....
}

#define TYPE_IDENTITY(classname) \
   static  char const* static_type_id() { static const char id[]=PP_STR(classname); } \
   virtual char const* object_type_id() const { return static_type_id(); }

struct Interface
{
  .....
  TYPE_IDENTITY(Interface)
  .....
};

class Foo : public Interface
{
  .....
  TYPE_IDENTITY(Foo)
  .....
};

.....
Interface* p;
.....
if(p->object_type_id() == Foo::static_type_id()) // можно сравнивать прямо адреса строк, т.к. они уникальны
  Foo* f = static_cast<Foo*>(p);

struct IElementOrContainer : enable_shared_from_this<IElementOrContainer>
{
  virtual shared_ptr<ISimpleElement> asElement() { return shared_ptr<ISimpleElement>(); }
  virtual shared_ptr<IContainer> asContainer()   { return shared_ptr<IContainer>();     }
};

struct ISimpleElement : IElementOrContainer
{
  shared_ptr<ISimpleElement> asElement() /*override*/ { return static_pointer_cast<ISimpleElement>(shared_from_this()); }
  .....
};

struct IContainer : IElementOrContainer
{
  shared_ptr<IContainer> asContainer() /*override*/ { return static_pointer_cast<IContainer>(shared_from_this()); }
  .....
};

S>std::map<long, boost::any>
S>

S>class ISimpleElement
S>{
S>    //...
S>};

S>class SimpleElementA : public ISimpleElement
S>{
S>    //...
S>};

S>class SimpleElementB : public ISimpleElement
S>{
S>    //...
S>};

S>class IContainer
S>{
S>    //...
S>};

S>class Container1 : public IContainer
S>{
S>    // ...
S>};

S>class Container2 : public IContainer
S>{
S>    // ...
S>};


S>int main()
S>{
S>    Container1 cont1;
S>    Container2 cont2;
S>    cont1.add(0, new SimpleElementA);
S>    cont1.add(1, new SimpleElementB);
S>    SimpleElementA* A = cont1.get<SimpleElementA>(0); // возвращает указатель на элемент нужного типа
S>    SimpleElementA* A1 = cont1.get<SimpleElementA>(1); // кидает эксепшн, что типа не соответствует типу хранимого элемента
S>    SimpleElementA* A2 = cont1.get<SimpleElementA>(3); // кидает эксепшн, элемента с таким id нет в контейнере

S>    cont2.add(2, new SimpleElementA);
S>    cont2.add(3, new SimpleElementB);
S>    cont2.add(4, &cont1); // еще не определился что будут передаваться указатели, скорее всего будут смарт поинтеры, но сейчас это не важно - просто пример

S>    SimpleElementA* A3 = cont2.get<SimpleElementA>(0); // ищет сначала внутри себя, а потом в других контейнерах внутри себя, когда находит - возвращает, не находит - кидает эксепшн
S>    Container1* p_cont1 = cont2.get<Container1>(4); // возвращает контейнер
S>}
S>

struct Holder
{
  virtual unsigned long id() = 0;
};

template<class T>
struct TypeHolder : public Holder
{
  virtual unsigned long id()
  {
    static int idlocation;
    return (unsigned long)&idlocation;
  }
};