Nous avons deux cas à traiter, soit une exception est propagée, soit aucune exception n'est propagée. Dans ce cas, nous devons avoir pour la fonction la structure suivante :

return_type function(...)
{
    return_type value;
    try
    {
    // Code du corps de la fonction.
    // Il n'est pas possibile d'utiliser l'instruction ''return''.
    }
    catch(...)
    {
       // Code à exécuter à la fin de la fonction
       throw; 
       // Réamorce l'exception capturée.
    }
    // Code à exécuter à la fin de la fonction
    return value;
}

Pour la fonction divide qui peut générer une fonction, nous allons devoir gérer les deux cas de figure, le premier cas où la fonction génère une exception, le second cas où la fonction ne génère pas d'exception. Ce qui nous donne le cas de figure suivant :

double divide(double theNumerator, double theDivisor)
    throw(division_by_zero)
{
    double result;
    try
    {
	if (theDivisor == 0)
		throw division_by_zero();
	result = theNumerator / theDivisor;  
    }
    catch(...)
    {
        std::cout << "Fonction terminée" << std::endl;
        throw;
    }
    std::cout << "Fonction terminée" << std::endl;
    return result;   
}

Cette approche n'est pas satisfaisante pour les raisons suivantes :

• la duplication de code, nous devons dupliquer au moins deux fois le code indiquant s'exécutant à la fin de la fonction (ceci peut-être compensé par un appel à une fonction qui factorise le code devant être exécuté en fin de la fonction).
• la nécessité de devoir stocker le résultat pour pouvoir ensuite le retourner après avoir exécuter le code de fin
• l'impossibilité d'avoir des points de sortie (return) multiples. Ceci peut-être compensé par des goto à une section finale correspondant à la fin de la fonction,

Pour la fonction divide, nous pouvons définir la classe:

class divide_finally
{
public :
    divide_finally(){}
    ~divide_finally() 
    {
        std::cout << "Fonction terminée" << std::endl; 
    }
};

et nous pouvons écrire le code de la fonction divide comme suit :

double divide(double theNumerator, double theDivisor)
    throw(division_by_zero)
{
    divide_finally finally;
    if (theDivisor == 0)
        throw division_by_zero();
    return theNumerator / theDivisor;
}

En fait, quand la fonction est appelée, la premier objet créé est un objet vide de type divide_finally. Lorsque nous quittons la fonction, soit suite à une exception, soit suite à un return, soit au fait que nous sommes arrivés à la fin de la fonction, les objets créés sont détruits dans l'ordre inverse de création. en conséquence, l'objet divide_finally sera le dernier objet créé, il sera détruit après tous les autres objets. Quand cet objet sera détruit, il appelera son destructeur qui contient le code à exécuter au moment de la fin de la fonction. Donc nous garantissons ainsi que ce code sera exécuté à la fin de la fonction.

Au passage, ceci fonctionne aussi pour des portées. Ainsi nous pouvons définir un deuxième objet de type finally que nous allons appeller divide_check_finally qui exécute le code une fois que le diviseur a été comparé à zéro.

class divide_check_finally
{
public :
    divide_check_finally(){}
    ~divide_check_finally() 
    {
        std::cout << "Test diviseur == 0 terminé" << std::endl; 
    }
};

et nous pouvons désormais écrire:

double divide(double theNumerator, double theDivisor)
    throw(division_by_zero)
{
    divide_finally finally;
    {
        divide_check_finally check_finally;
        if (theDivisor == 0)
            throw division_by_zero();
    }
    return theNumerator / theDivisor;
}

Dans ce cas, le code du destructeur de check_finally sera exécuté avant de propagé l'exception ou avant d'exécuter la division.