[C++]Eccezioni nella classe Rational

[TheBestNapoli]

Ciao a tutti, ho un esercizio che dice:
Scrivete un programma per verificare che tutti i distruttori degli oggetti creati in un blocco sono chiamati prima che venga lanciata un'eccezione di tale blocco. Si adoperi la classe rational come esempio.
In pratica dovrebbe essere un esercizio semplice, infatti basta creare la classe Rational (che ho già fatto anche con l'overloading degli operatori), inserire nel distruttore un cout e lanciare una qualsiasi eccezione per vedere se il distruttore viene chiamato prima del lancio dell'eccezione.
Ho supposto che l'eccezione che bisogna gestire nella classe Rational sia la divisione per zero e quindi l'header.h è questo

#include <iostream>

using namespace std;

class Rational{
		friend Rational operator+(const Rational &, const Rational &);
		friend Rational operator-(const Rational &, const Rational &);
		friend Rational operator*(const Rational &, const Rational &);
		friend Rational operator/(const Rational &, const Rational &);
		friend ostream &operator<<(ostream &, const Rational&);
	public:
		Rational(int n = 0, int d = 1): num(n), den(d){}
		~Rational(){cout<<"Distruttore\n";}
	private:
		int num, den;
		int gcd(int j, int k){if(k==0)return j; return gcd(k,j%k);}
		void reduce(){int g=gcd(num, den); num/=g; den/=g;}
};

class DivideByZero{
	public:
		DivideByZero(): message("Denominatore uguale a zero!"){}
		const char *what() const {return message;}
	private:
		const char *message;
};

nel main dove lancio l'eccezione per verificare se il numeratore è uguale a zero? Forse non mi conviene fare il costruttore di default? Mi conviene fare un costruttore normale in cui posso inserire da tastiera i valori? (A quel punto credo sia banale il lancio dell'eccezione)

#include "header.h"

int main()
{
        //manca il throw!
	try
	{
		Rational x(3,2), y(5,9), z;
		cout<<"x = "<<x<<endl;
		cout<<"y = "<<y<<endl;
		z = x + y;
		cout<<"z = x + y = "<<z<<endl;
		z = x - y;
		cout<<"z = x - y = "<<z<<endl;
		z = x * y;
		cout<<"z = x * y = "<<z<<endl;
		z = x / y;
		cout<<"z = x / y = "<<z<<endl;
	}
	catch(DivideByZero &ecc)
	{
		cout<<"ERRORE: "<<ecc.what()<<endl;
	}
	return 0;
}

Grazie a tutti.

[tomminno]

Scrivete un programma per verificare che tutti i distruttori degli oggetti creati in un blocco sono chiamati prima che venga lanciata un'eccezione di tale blocco.

Il testo mi pare poco preciso, tecnicamente parlando non è possibile che vengano richiamati i distruttori degli oggetti nel blocco prima che l'eccezione venga sollevata. Caso mai possono essere chiamati dopo, al momento in cui gli oggetti finiscono fuori dallo scope per lo stack unwinding.

L'interpretazione che do io al testo è di verificare che vengano chiamati tutti i distruttori per gli oggetti istanziati.
Un qualcosa di stupido, ma non automatizzato, sarebbe di scrivere sullo standard output "ctor" per ogni costruttore chiamato e "dtor" per ogni distruttore richiamato e vedere se il numero di ctor stampati sia uguale a quello di dtor.
Un'alternativa automatizzata ma sempre banale richiede la modifica alla classe rational passandogli ad esempio uno stringstream dove la classe può scrivere così da poter controllare nel main il numero di ctor/dtor.

Una soluzione molto più pulita sarebbe quella di far sollevare eventi al costruttore e al distruttore della classe e nel main registrarsi per la notifica di questi eventi.
C'è un problema che potrebbe non interessare certamente un esercizio di tale livello, che i distruttori non dovrebbero mai sollevare eccezioni, nel caso di eventi non è dato sapere cosa farà il destinatario dell'evento.