[C++] Gestire le eccezioni con <stdexception>

[dunix87]

Salve, sto scrivendo una classe template per uno stack e all'interno della funzione pop faccio uso di di una throw out_of_range della libreria stdexceptio.
Io non sono ancora molto pratico è vorrei sapere come faccio a gestire l'eccezzione nel main. Spero ci sia qualcuno che mi può dare una mano, grazie.

Il codice del metodo è:

template <class T>
T stack<T>::pop(){
    if (size==0) throw std::out_of_range("Pila vuota");; 
    testa=(testa)->next;
    dat=testa->dato;
    size--;
    return dat;
};

Mentre nel main vorrei gestire l'eccezione causata dallo stack vuoto, stampando a video "Pila vuota". Come faccio a recuperare la stringa di throw std:ut_of_range?

int main(){
     int i;
     stack<int>* a=new stack<int>;
     try {i=a->pop();}
     catch (std::out_of_range &) {
        //qui vorrei stampare la stringa che si trova in pop out_of_range ???
    }
     return 0;
}

[shodan]

Originariamente inviato da dunix87

int main(){
     int i;
     stack<int>* a=new stack<int>;
     try {
          i=a->pop();
     } catch (std::out_of_range& err)  {
        cerr << err.what() << endl; 
    }
     return 0;
}

Ricorda di deallocare "stack<int>* a" alla fine.

[dunix87]

Ah grazie mille, si è rivelato più semplice di quanto immagginavo.

A questo punto avrei un altro dubbio a rigurado le eccezioni. Se ad esempio non sapessi a priori che l'eccezzione generata dalla funzione pop fosse di tipo out_of_range, esiste la possibilità di eseguire una catch su eccezione generica? O dovrei implementarlo in un altor modo rispetto al precedente? Sono ancora un po' confuso su quest'argomento...

[shodan]

Dovrebbe bastare inserire un

catch (...)

per acchiappare ogni tipo di eccezione. Ovviamente non si può sapere quale.

Puoi mettere anche più catch in cascata nel main.

try {
 ...
} catch (std::out_of_range& err) {
  ...
} catch (std::bad_alloc& err) {
  ...
} catch (std::runtime_error& err) {
  ...
} catch (...) {
} 

[dunix87]

Ok grazie di nuovo, ovviamente nel caso ci catch(...) non potrei ottenere la stringa di errore, giusto?

Se invece utilizzassi come identificatore la classe che contiene le eccezioni che io utilizzo, in questo logic_error, cioè:

catch (std::logic_error &err) {
        cout << err.what() << endl; 
    }

Funzionerebbe ancora o andrei incontro ad errori inaspettati in condizioni particolari?
Perchè facendo una prova rapida a rigore sembra funzionante

[MacApp]

std:ut_of_range è o non è derivata (direttamente o no) da std::exception?
Quindi cattura solo (nell'ordine) "const std::exception &" e "..."!
Altrimenti l'astrazione (e tutto il paradigma della programmazione ad oggetti) a che serve?
;-)

[dunix87]

ah... ok grazie...
Non riuscivo bene a capire la struttura della libreria in effetti con std::exception &... le richiama tutte senza la necessità di ulteriori generalizzazioni.

Forse dovrei aprire un altro post per questo, ho cambiare il titolo della discussione visto ke avrei bisogno di qualke altro kiarimento in merito alla classe stack ke sto costruendo.

Vi posto i quesiti intanto:
Non essendo ancora molto pratico mi rimangono vari dubbi.
1)Ho notato che si può dichiare un oggetto di una classe come classe nome_oggetto
oppure come classe* nome_oggetto=new classe.
Vi posto il mio esempio per spiegarmi meglio.

int main(){
     int t;
     stack<int> a;
     stack<int>* b=new stack<int>;
     a.push(5);
     b->push(5);
     t=a.pop();
     t=b->pop();
     delete &a;
     delete b;
     system("PAUSE");
     return 0;
}

Che differenze ce fra l'oggetto a e quello b, oltre che il secondo è un puntatore? Quale fra i due è preferibile usare?

2)Inoltre scrivendo la classe mi è sorto un altro dubbio, data anche la mia ancora scarsa affinità col linguaggio, cioè se io uso come parametro di un metodo della mia classe un oggetto della stessa classe, in teoria dovrei avere accesso dal metodo agli attributi privati dell'oggetto, o mi sbaglio?

Vi ringrazio dell'aiuto fin qui fornitomi e spero di essere stato chiaro, inoltre chiedo scusa se ho sbagliato a postare questo messaggio.

[shodan]

Non essendo ancora molto pratico mi rimangono vari dubbi.
1)Ho notato che si può dichiare un oggetto di una classe come classe nome_oggetto
oppure come classe* nome_oggetto=new classe.
Vi posto il mio esempio per spiegarmi meglio.

int main(){
     int t;
     stack<int> a;
     stack<int>* b=new stack<int>;
     a.push(5);
     b->push(5);
     t=a.pop();
     t=b->pop();
     delete &a;
     delete b;
     system("PAUSE");
     return 0;
}

Che differenze ce fra l'oggetto a e quello b, oltre che il secondo è un puntatore? Quale fra i due è preferibile usare?

L'oggetto a è costruito sullo stack della funzione e pertanto viene distrutto quando termina il main; da ciò deriva che delete &a è male (infatti non fai delete &t).
Nel secondo caso l'oggetto new stack<int> è costruito sull'heap e collegato tramite il puntatore b e alla fine va giustamente deallocato.
Qui sorge un problema se viene sollevata un'eccezione non gestita: l'istruzione delete b non verrà mai invocata (in casi simili si utilizzano puntatori furbi) e il programma termina immediatamente.

cioè se io uso come parametro di un metodo della mia classe un oggetto della stessa classe, in teoria dovrei avere accesso dal metodo agli attributi privati dell'oggetto, o mi sbaglio?

Certo. Altrimenti costruttori di copia e operatori di assegnamento non si potrebbero fare.

[dunix87]

L'oggetto a è costruito sullo stack della funzione e pertanto viene distrutto quando termina il main; da ciò deriva che delete &a è male (infatti non fai delete &t).
Nel secondo caso l'oggetto new stack<int> è costruito sull'heap e collegato tramite il puntatore b e alla fine va giustamente deallocato.
Qui sorge un problema se viene sollevata un'eccezione non gestita: l'istruzione delete b non verrà mai invocata (in casi simili si utilizzano puntatori furbi) e il programma termina immediatamente.

quindi da un certo punto di vista è meglio utilizzare il costrutto: classe oggetto almeno non corro il rischio di riempire l'heap in caso di eccezione imprevista oppure sarò costretto a preventivare tutte le eccezioni.

Cosa intendi per puntatori furbi?

[shodan]

Sono classi che si utilizzano come puntatori.
Quello che la libreria del C++ mette a disposizione è std::auto_ptr (ma ce ne sono di migliori ad esempio nella libreria boost).

Un esempio veloce (prendo spunto dal tuo codice)

#include <memory>

int main() {
   
   std::auto_ptr<stack<int> > ptr(new stack<int>);
   ptr->pop(); // eccezione
} 

(nota lo stacco delle due > >, altrimenti il compilatore lo interpreta come >>)
L'eccezione non è gestita, ma il distruttore di auto_ptr è invocato comunque e libera la memoria.
Comodo quando non si riesce a prevedere il flusso del programma. (Ad esempio a causa di un uso massiccio delle eccezioni)