[C++] Crash al termine del main

[nostradamus1915]

Qualcuno sa spiegarmi perché siffatta funzione provoca un crash alla fine del main? Tutto viene eseguito correttamente, ma quando termino il programma va in crash.
Il programma consiste nel trasferire su un file binario le informazioni relative a degli oggetti(serializzazione).

Funzione serial:

bool serialize(const buffer & filepath,const PilaPacchi P,const int n){
     ptr papp=P.getL();
     char * app;
     int scrv;
     float fapp;
     
     ofstream out(filepath,ios::out|ios::binary);
     if(!out) return false;
     else{
          int count=n;
          out.write((char *)&count,sizeof(int));
          for(int i=0;i<count;i++){
                  scrv=papp->E.getC();
                  out.write((char *)(&scrv),sizeof(int));
                  fapp=papp->E.getKG();
                  out.write((char *)(&fapp),sizeof(float));
                  writeS(out,papp->E.getI());
                  delete [] app;
                  papp=papp->next;
                  }
          out.close();
          return true;
          }
     }

Funzione writeS che viene richiamata da serial:

void writeS(ofstream & out,const char * b){
     int s = strlen(b);
     out.write((char *)&s,sizeof(int));
     out.write(b,s);
     }

Oggetto PaccoPostale:

class PaccoPostale{
      friend ostream& operator<<(ostream&,const PaccoPostale &);
      friend istream& operator>>(istream&,PaccoPostale &);
      protected:
             float peso;
             int codice;
             char * indirizzo;             
             virtual ostream& print(ostream&) const;
             virtual istream& leggi(istream&);
      public:
             //costruttori
             PaccoPostale(): peso(0), codice(0), indirizzo("") {}
             PaccoPostale(const float,const int,char *);
             PaccoPostale(const PaccoPostale &);
             
             //distruttore
             ~PaccoPostale();
             
             //func
             void print() const;
             
             //overload
             PaccoPostale & operator=(const PaccoPostale &);
             
             //sets
             void setC(const int c) { codice=c; }
             void setP(const float p) { peso=p; }
             void setI(char * c) { allocaCC(indirizzo,c); }
             
             //gets
             const int getC() const { return codice; }
             const float getKG() const { return peso; }
             const char * getI() const { return indirizzo; }
      };

Oggetto PilaPacchi

struct record;

typedef record * ptr;

typedef struct record{
        PaccoPostale E;
        ptr next;
        };

class PilaPacchi: public PaccoPostale{
      private:
             ptr l;
             friend istream& operator>>(istream &,PilaPacchi &);
      public:
             //costruttore
             PilaPacchi(): l(0) {}
             
             //pop,push,top
             void push(const PaccoPostale &);
             PaccoPostale& pop();
             PaccoPostale& top() const;
             
             //isfull,isempty
             bool isfull() const { return false; }
             bool isempty() const { return l==0; }

             //stampa
             void stampa();
             
             //leggi da file
             bool deserialize(const buffer &) throw(FileExcept);
             
             //distruttore
             ~PilaPacchi();
             
             //get
             const ptr getL() const { return l; }
             
             //
             void setL(ptr p) { l=p; }
      };
      
bool serialize(const buffer &,const PilaPacchi,const int);

In teoria tutte le funzioni sono funzionanti (le ho provate tutte), crasha solo quando uso serialize e alla fine del programma, quindi esegue la funzione correttamente ma provoca un crash del main quando questo termina.
Idee?

[shodan]

Togliere quel

delete [] app;

che non inizializzi, non usi e che cancelli count volte, corrompendo l'heap.