Wczytywanie z pliku w projekcie na programowanie obiektowe

Witam, już ponad tydzień męczę się żeby napisać funkcję której mi brakuje do ukończenia projektu a mianowicie wczytywanie z pliku polegające na wypełnianiu pól obiektów danej klasy wartościami, które znajdują się w pliku . Zapis do pliku działa, jak i wiele innych funkcji , natomiast tej po niezmiernie dużej ilości prób i przeróżnych rozwiązań na które wpadłem czy też pomocy ze strony innych wciąż nie udaje mi się naprawić. Projekt dotyczy programowania obiektowego, dziedziczenia klas, całość jest oparta o schemat listy dwukierunkowej, całość nie jest zbyt skomplikowana. Osoby które mają chwilę wolnego czasu i byłyby skore w jakikolwiek sposób pomóc dać wskazówkę/zasugerować rozwiązanie proszę o odezwanie się do mnie w prywatnej wiadomości ponieważ nie chcę tu udostępniać całego kodu programu.
Z góry dziękuję,
theCember

Podaj swoją funkcje zapisującą do pliku.

http://pastebin.com/xxbrjNUG
wrzuciłem 2 przykładowe klasy gdzie jedna dziedziczy z drugiej oraz funkcję zapisującą

To się nadaje jedynie na śmietnik.
Może poczytaj to i owo w jakimś kursie.
Tworzysz klasy więc zrób jakiś kontener, oraz prawdziwą hierarchię z metodami wirtualnymi.

Może inaczej:
http://pastebin.com/kEAxAEux <--- jest cały kod programu i jest taki problem: Najpierw w menu wybiera się węzeł (polecenie CD), potem tworzę obiekt (MO) w danym węźle zapisuje go do pliku. Potem np wyłączam program i chcę wczytać jakiś obiekt z pliku .txt który przed chwilą utworzyłem za pomocą tego programu i coś jest nie tak w funkcji wczytującej ponieważ program zaczyna się sypać.
Mam nadzieję, że teraz wszystko wygląda dużo jaśniej, pokazywanie "strzępków" programu nie było dobrym pomysłem, pozdrawiam i liczę na pomocne odpowiedzi :)

Oczywiście polecam dla takich rzeczy coś a la boost::Archive, ale jak się chce ręcznie w dosyć prosty sposób zrobić serializacje to polecam coś w tym rodzaju:

#include <map>
#include <vector>
#include <typeinfo>
#include <string>
#include <fstream>
#include <iostream>
using namespace std;

class Figure
  {
   protected:
   unsigned Id;
   static unsigned nextId()
     {
      static unsigned Id=0;
      return ++Id;
     }
   public:
   Figure():Id(nextId()) { }
   Figure(ifstream &fs) { fs.read((char*)&Id,sizeof(Id)); }
   virtual void save(ofstream &fs) { fs.write((char*)&Id,sizeof(Id)); }
   virtual ~Figure() {}
   virtual ostream &prn(ostream &s)const { return s<<"Figure "<<Id; }
  };
ostream &operator<<(ostream &s,const Figure &F) { return F.prn(s); }

class Square:public Figure
  {
   protected:
   double SideA;
   public:
   Square(double SideA):SideA(SideA) {}
   Square(ifstream &fs):Figure(fs) { fs.read((char*)&SideA,sizeof(SideA)); }
   virtual void save(ofstream &fs) { Figure::save(fs); fs.write((char*)&SideA,sizeof(SideA)); }
   virtual ostream &prn(ostream &s)const { return s<<"Square "<<Id<<" "<<SideA; }
  };

class Rectangle:public Square
  {
   protected:
   double SideB;
   public:
   Rectangle(double SideA,double SideB):Square(SideA),SideB(SideB) {}
   Rectangle(ifstream &fs):Square(fs) { fs.read((char*)&SideB,sizeof(SideB)); }
   virtual void save(ofstream &fs) { Square::save(fs); fs.write((char*)&SideB,sizeof(SideB)); }
   virtual ostream &prn(ostream &s)const { return s<<"Rectangle "<<Id<<" "<<SideA<<" "<<SideB; }
  };
  
class Circle:public Figure
  {
   protected:
   double Radius;
   public:
   Circle(double Radius):Radius(Radius) {}
   Circle(ifstream &fs):Figure(fs) { fs.read((char*)&Radius,sizeof(Radius)); }
   virtual void save(ofstream &fs) { Figure::save(fs); fs.write((char*)&Radius,sizeof(Radius)); }
   virtual ostream &prn(ostream &s)const { return s<<"Circle "<<Id<<" "<<Radius; }
  };

struct Filer
  {
   typedef Figure *maker(ifstream &fs);
   typedef map<string,maker*> filermap;
   static filermap &filerReg();
   template<class Type> static Figure *make(ifstream &fs) { return new Type(fs); }
   static void Save(Figure *f,ofstream &fs)
     {
      string name(typeid(*f).name());
      const unsigned char len=name.size();
      // tu wypadało by zabezpieczyć się na wypadek jeżeli obiekt nie jest zarejestrowany w filerReg()
      fs.write((char*)&len,1);
      fs.write(&name[0],len);
      f->save(fs);
     }
   static Figure *Load(ifstream &fs)
     {
      unsigned char len;
      string name;
      fs.read((char*)&len,1);
      if(!fs) return 0;
      name.resize(len);
      fs.read(&name[0],len); // trochę brzydko ale nie chciało mi się przez char bufor[256] robić
      return filerReg()[name](fs);
     }
  };

Filer::filermap &Filer::filerReg()
  {
   static Filer::filermap tb;
   if(!tb.size())
     {
      tb[string(typeid(Square).name())]=&Filer::make<Square>;
      tb[string(typeid(Rectangle).name())]=&Filer::make<Rectangle>;
      tb[string(typeid(Circle).name())]=&Filer::make<Circle>;
     }   
   return tb;
  }

int main()
  {
   vector<Figure*> tb;
   tb.push_back(new Rectangle(5,10));
   tb.push_back(new Circle(10));
   tb.push_back(new Square(7));
   for(size_t i=0;i<tb.size();++i) cout<<*(tb[i])<<endl;
   ofstream fout("figures.bin",ios::out|ios::binary);
   for(size_t i=0;i<tb.size();++i) Filer::Save(tb[i],fout);
   fout.close();
   cout<<"========================"<<endl;
   vector<Figure*> bt;
   ifstream fin("figures.bin",ios::in|ios::binary);
   for(Figure *f;(f=Filer::Load(fin))!=0;) bt.push_back(f);
   fin.close();
   for(size_t i=0;i<bt.size();++i) cout<<*(bt[i])<<endl;   
   
   return 0;
  }