[C++] Problema con pila dinamica.

[fedee91ee]

Salve ragazzi!
Avrei un problema con un programma che implementa una classe libro e costituisce poi una pila di libri. Il problema è: dopo aver costituito la classe, riesco a stampare a video il libro (comprensivo di codice -stringa statica-, titolo -allocato dinamicamente-, numero pagine, anno pubblicazione) mentre se voglio stampare la pila di libri, il programma stampa tutto bene tranne il titolo (stringa allocata dinamicamente) di ogni libro al posto del quale compaiono caratteri speciali. Non so se mi spiego, comunque ora posto una parte del codice.

Classe libro:

const int dim=50;

class Libro{
      private:
             char codice[dim];
             char* titolo;
             int num_pagine;
             int anno_pubbl;
      public:
             Libro(char* c="", char* t="", int num_p=0, int anno_p=0);
             Libro(const Libro &);
             ~Libro(){delete [] titolo;}
             void set_titolo(char*);
             char* get_titolo()const{return titolo;}
             bool check_copyright(const Libro &);
             friend ostream & operator <<(ostream&, Libro&);
             friend istream & operator >>(istream&, Libro&);
      };

Implementazione costruttore e operatore di flusso:

Libro::Libro(char* c, char* t, int num_p, int anno_p){
            strcpy(codice, c);
            titolo=new char[strlen(t)+1];
            strcpy(titolo,t);
            num_pagine=num_p;
            anno_pubbl=anno_p;
}

ostream & operator <<(ostream& os, Libro& L){
        os<<"\nCodice:"<<L.codice;
        os<<"\nTitolo:"<<L.titolo;
        os<<"\nNumero pagine:"<< L.num_pagine;
        os<<"\nAnno pubblicazione:"<< L.anno_pubbl;
        return os;
}

Pila:

typedef Libro E;
struct Record;
typedef Record* Pila;


struct Record{
       E elem;
       Pila next;
};

void start(Pila&);
void top(const Pila&, E&);
bool empty(const Pila&);
bool full(const Pila&);
void push(Pila&, const E);
void pop(Pila&, E&);
void stampa(const Pila&);

Stampa pila:

void stampa(const Pila& p){
     Record * ptr;
     ptr=p;
     while(ptr)
     {
        cout << ptr->elem << endl;
        ptr=ptr->next;
     }   
}

Non ho postato tutto il codice pensando di aver postato la parte utile, ma se c'e bisogno posso postarlo tutto! Vi ringrazio in anticipo!
ps. Siate clementi è da poco che ho cominciato con il c++ e anche con il forum!

[Gimli[2BV!2B]]

Non noto errori netti nella porzione di codice che hai postato, c'è un rischio buffer overflow di Libro.codice e qualche warning dovuto alla mancata precisazione di qualche const.

I sospetti più grandi li ho sulla mancata definizione di un costruttorie di copia che si occupi di clonare la stringa allocata.
Usando quell'oggetto in contenitori è probabile che nascano delle copie temporanee: queste saranno inizializzate invocando il costruttore di copia.
In assenza di una definizione esplicita verrà usato il costruttore di default (che non è molto intelligente, poverino).
Ad un certo punto le copie finiranno la loro vita utile e... delete [] titolo!

Altro sospettabile è set_titolo(char*) di cui non hai riportato l'implementazione.

Oppure potrebbero accadere cose spiacevoli se si innesca il buffer overflow causa codici lunghi, tipo

Libro libro( "test test test test test test test test test test test test test test test test test", "tost", 105, 2001 );

Però in questo caso l'errore sarebbe molto probabilmente segnalato da un segmentation fault.

[fedee91ee]

Prima di tutto, grazie per la risposta.
Comunque, il costruttore di copia è stato definito all'interno della classe, anche se in effetti ripensandoci ho avuto proprio dei dubbi nell'implementazione di questo, ma stupidamente non l'ho postata pensando che non avesse a che fare col mio problema.
Eccola:

Libro::Libro(const Libro & L){
            strcpy(codice, L.codice);
            titolo=new char[strlen(L.titolo)+1];
            strcpy(titolo,L.titolo);
            num_pagine=L.num_pagine;
            anno_pubbl=L.anno_pubbl;
}

E per quanto riguarda i "const" di cui parlavi, dove ritieni che ce ne sia bisogno?

Edit:
Dimenticavo l'implementazione di set_titolo:

void Libro::set_titolo(char* t){
           titolo=new char[strlen(t)+1];
           strcpy(titolo,t); 
}

Riedit:

E tra l'altro non so se mi sono spiegata bene, ma non mi da problemi in casi tipo:

Libro libro("aaa","bbbb",1,1)

ma in casi del tipo:

E e("aaa","bbb",1,1)

quindi solo quando stampo il libro attraverso la pila e solo per quanto riguarda il titolo mi da problemi.
Scusami se mi dilungo..

[Gimli[2BV!2B]]

Scusa, mi son perso la dichiarazione Libro(const Libro &) e son partito per la tangente.
La tua implementazione del costruttore di copia mi sembra corretta, al momento ho un dubbio sulla possibilità di un meory leak di titolo, ma direi che non dovrebbe accadere.

set_titolo invece è destinato a generare memory leak, perché non deallochi titolo prima di sovrascriverlo con il nuovo indirizzo allocato.

Ora mi chiedo come crei le struct che vanno a costituire la lista.
Molto probabilmente è necessario l'operatore assegnamento per un motivo molto simile a quello che ho cercato di descrivere prima per il costruttore di copia, cioè dei delete[] che partono su puntatori che rimangono condivisi tra più oggetti.

I warning dei const che ho accennato son questi (con gcc (Debian 4.6.2-9) 4.6.2):

warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]

Per far ordine:

Libro(const char* c="", const char* t="", const int num_p=0, const int anno_p=0);

[fedee91ee]

Devo ringraziarti infinitamente. Dopo aver ridefinito l'operatore di assegnazione, il programma finalmente funzione.. anche se avrei dovuto pensarci io..
Ho aggiustato anche le altre cose che mi dicevi riguardo set_titolo e i const.
Ti ringrazio ancora, finalmente ho risolto!