Project stuck due to pointers

parse xml.h
    #pragma once
    #include <vector>
    #include <iostream>
    #include <string>
    #include <map>
    #include <fstream>
    using namespace std;
    
    namespace prog {
    
    	class MainNode
    	{
    	public: 
    		vector<Mainnode*> *elements;
    		MainNode () { elements = NULL;}
    		virtual void writeCode(fstream &outfile) = 0; 
    		
    	};
    	   class ScxmlElement : public MainNode 
    	   {
    	   public:
    		  string version, initialstate, name;
    		  ScxmlElement () { elements = new vector<Mainnode*> ();}
    		  void writeCode(fstream &outfile){
          outfile<<"var JS"<<" "<<"= new Statechart"<<" "<<"("<<initialstate<<")"<<endl;
    			  
    			 </*for (auto it = elements->begin(); it != elements->end(); ++it) {
    				  (*it)->writeCode(outfile);
                delete *it;
        }*/ //i tried to use this but got error (debug assertion fail) and then left it>
    	for (long index=0;index<(long)elements->size();++index){
    		 outfile<<"index at element: "<<(*elements).at(index)<<endl;
    				  MainNode *node = elements->at(index);
    				  outfile<<node<<endl;
    				 node->writeCode(outfile);//i think this call has problem
    				 }
    		  }
    	    };
    		class ScxmlDatamodel : public MainNode
    		{
    		public: 
    			
    			map<string,string> data;
    			void writeCode(fstream &outfile){
    	for(map<string,string>::const_iterator it= data.begin();it!=data.end();++it)
    	 outfile<<"var"<<" "<<(*it).first<<" = "<<(*it).second<<endl;
    			}
    		};
    		class ScxmlState : public MainNode
    		{
    		public:
    			string id, module;
    			ScxmlState () { elements = new vector<Mainnode*> ();}
    			void writeCode(fstream &outfile){
    	outfile<<"\nvar"<<" "<<id<<"State = new State ("<<"\""<<id<<"\""<<")"<<endl;
    			
    	for (long index=0;index<(long)elements->size();++index){
    				  MainNode *node = elements->at(index);
    				  node->writeCode(outfile);
    				}
    				outfile<<"JS"<<".states[\""<<id<<"\"] = "<<id<<"State"<<endl;
    			}
    
    		};
    		class ScxmlTransition : public MainNode
    		{
    		public: 
    			string eventname, target;
    			string cond;
    			MainNode *parent;
    			void writeCode(fstream &outfile){
     outfile<<dynamic_cast<scxmlstate*>(parent)->id<<"State.handler[\""<<eventname<<"\"] = function (event) {";
    				if(!cond.empty())
    	outfile<<"\nif("<<cond<<") return \""<<target<<"\"\nelse return null\n}";
    				else if(!target.empty())
        		outfile<<"\nreturn \""<<target<<"\" }"<<endl;
    				else outfile<<"\nreturn null }"<<endl;
    			}
    		};
    }
    class Generator {
    public:
    	string path;
    	Generator (string filepath) { path=filepath; }
    	void write(prog::ScxmlElement module){
    		fstream file(path+"tictac_gen.js", ios::out | ios::app);
    		file<<"\ndocument.write('<script language=\"javascript\" type=\"text/javascript\"src=\"statemachine.js\"></script>')"<<endl;
    		module.writeCode(file);
    		file.close();
    	}
    };

//parse xml.cpp
#include "parse xml.h"
#include "pugixml.hpp"
#include <cstdio>
using namespace pugi;
using namespace std;

class ScxmlParser
        {
        protected:
        xml_document doc;
        public:
            ScxmlParser () {}
            prog::ScxmlElement parse();
        };

        prog::ScxmlElement ScxmlParser::parse ()
           {
               xml_parse_result result = doc.load_file("C:\FILE.xml");
               xml_node xMainNode = doc.child("scxml");
               prog::ScxmlElement module;
               module.version=xMainNode.attribute("version").value();
               if(module.version.empty())
                throw string("Attribute version missing");
                           module.initialstate=xMainNode.attribute("initialstate").value() ;
               if(module.initialstate.empty())
                throw string("Attribute initialstate missing");

               module.name=xMainNode.attribute("datamodel").value();
               if(module.name.empty())
                throw string("Attribute datamodel missing");


         prog::ScxmlDatamodel datamodel;
         string id =xMainNode.child("datamodel").child("data").attribute("id").value();
         string expr=xMainNode.child("datamodel").child("data").attribute("expr").value();
          if(id.empty() || expr.empty())
           throw string ("Specified nodes or Attributes are missing");
         else datamodel.data.insert(make_pair(id,expr));
         module.elements->push_back(&datamodel);

         for(map<string,string>::const_iterator it=datamodel.data.begin();it!=datamodel.data.end();++it)


         xml_node states=xMainNode.child("state");
         prog::ScxmlState state;
         for(xml_node states=xMainNode.child("state");states;states=states.next_sibling("state")){
             state.id=states.attribute("id").value();
             if(state.id.empty())
                  throw string ("Attribute state id missing");
                  state.module=module.name;
                  module.elements->push_back(&state);


                 prog::ScxmlTransition transition;
                for(xml_node transitions=states.child("transition");transitions;transitions=transitions.next_sibling("transition")){
                       transition.eventname=transitions.attribute("event").value();
                       if(transition.eventname.empty())
                         throw string ("Attribute transition event missing");
                       string condition=transitions.attribute("cond").value();
                     if(!condition.empty()){
                          transition.cond=condition;
                          }
                      transition.target=transitions.attribute("target").value();
                      transition.parent=&state;
                      state.elements->push_back(&transition);


                  }
            }
        return module;
        }

void main(){
    ScxmlParser p;
    string getpath;
    prog::ScxmlElement e;
    cout<< "Enter file path"<<endl;
    cin >> getpath;

    try{ e=p.parse();} catch (string s) { cout << s << endl; }
    Generator gen(getpath);

    gen.write(e);
    getchar();

}