C++ структура дърво/гора за възли от различни типове класове

\\при прилагане на решение, намерено с кастинг върху общ базов клас

\\ с виртуални членове.

\\разбрах за универсални препратки, защото това е друг въпрос, създадох нов:

https://stackoverflow.com/questions/29590429/c-is-it-possible-to-use-universal-references-for-a-tree-forest-with-nodes-that

моля, вижте също този първоначален въпрос.

Искам да организирам йерархичната дървовидна структура на обекти с различни типове.

Решението трябва да върши работата си по време на компилиране, така че разбрах, че трябва да направя това с шаблони в най-добрия случай без никакво кастинг.

след някои опити, които са в editlog и имаха някои основни недостатъци.

намерих начин да го разделя на два класа

• гора, която съхранява всички възли и им дава две координати индексните числа във вектора‹ вектор ‹...> >

• възел шаблон ‹ T >, който съхранява T обекта и връзката с другите възли

моята идея все още няма начин за достъп до членските функции на обектите, съхранени в класа на възела, без да се нарушава уникалния_показател, който осигурява управлението на ресурсите.

и бих искал да знам как да осигуря безопасен тип при достъп до обект вътре в класа на възела.

може да има грешки вътре в кода, аз съм напълно сигурен, че няма да се компилира, въпросът е за концепцията.

Въпросите са вътре в коментарите.

версия 4:

 class Forest
 {
  public:
     template<typename T>
     {friend class Node<T>;} \\every Node<T> should have access to the forest
     Forest();
     ~Forest();
     Forest(const Forest&)=delete;  \\does not make any sense to copy or assign the forest to another forest.
     Forest operator=(const Forest&)=delete;
     int insertroot()  \\every tree has a void nullptr seed/root so that the forest does not need to be templatet, returns the treenumber
     {    \\implementation
     if(this->Nodes.size()==0)
        {
           std::vector<std::unique_ptr<Node<void> > > h0;
           h0.push_back(std::unique_ptr<Node<void>(new Node<void>(nullptr));
           this->Nodes.push_back(h0);
        }else
        {
             this->Nodes[0].push_back(std::unique_ptr<Node<void>(new Node<void>(nullptr,this)));
        }
     return this->Nodes[0].size()-1;

     }
     Node<void>* getroot(int i)   \\ to later allow access to the children and the Objects inside them
  {
     if(Nodes.size>0){
      if((i>0)&(i<Nodes[0].size()))
      {
          return Nodes[0][i].get();
      }
  }
  private:
      std::vector<std::vector<unique_ptr<Node<void> > > nodes; \\is it possible to fill this vector with any Node<T>? its a vector*2 to a unique_ptr to a classpointer with a member pointer to any class. from what i read about templates they create a extra class  for every type, so basicly the unique_ptr have a different type and i cannot store different types in a vector without casting?
 }

 template<typename T>
 class Node
 {
   public:
      Node(T n,Forest * Fo) \\ every Node is in the forest and has access to the other nodes and forest information
      :object(std::unique_ptr(n)),F(Fo)
      {
          if(n==nullptr)
          {    
               this->lvl=0;
               this->place=F->Node[0].size();
               this->parent=-1;
          }
      }
      ~Node();
      Node(const Node&)=delete;
      Node operator=(const Node&)=delete;
      T getObject(){return object.get();} \\how does the compiler know the type? see getchild 

      template<typename C>
      {
         Node<C> * getchild(int){}   \\not yet exsisting implementation of get child[int] how do i teach the compiler what int responds to what type?
                                     \\when i understand templates correct then Node<C> are different Classes for every C??
        addChild(C c)
        {
           Node * n=new Node(c,this->F);
           n->parent=this->place;
           n->lvl=this->lvl+1
           if(F->nodes.size()<=n->lvl)
           {
              n->place=0;
              h0=std::vector<unique_ptr<Node<C>> >;  
              h0.push_back(unique_ptr<Node<C>(n))
              F->Nodes.push_back(h0); \\are vector<uniptrNode<C> > and vector<uniptrNode<void>> compatible?
           }else
           {
              n->place=F->nodes[n->lvl].size();
              F->Nodes[n->lvl].push_back(unique_ptr<Node<C> >(n));
           }
           this->children.push_back(c->place);
        } 
      }        
   private:
     int parent,place,lvl;
     std::vector<int> children;
     unique_ptr<T> object;
     Forest * F;
 }

някой знае ли начин за прилагане на контейнер като този? може би има някакъв абстрактен тип тип, за който не разбрах, така че направете го, мога да добавя тип метод getnodetype(int) или checknodetype(int,type), мога ли да присвоя това с auto nodex=y->getObject()? Но как тогава компилаторът знае какви методи има и какви няма nodex?

РЕДАКТИРАНЕ: премахнах оригиналната публикация, защото v4 е много близо до работещо решение, версия 1-3 трябва да бъде в editlog