Exceptions, héritage et méthodes virtuelles

Version imprimable

Bonjour,

Cela fait plusieurs heures que je bloque sur le problème suivant. Voici mon bout de code de test de l'architecture des exceptions pour mon projet :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
#include <iostream>
#include <string>
 
using namespace std;
 
// Classe de base des exceptions
class Exception {
public :
    Exception() : next(NULL) {}
    Exception& add(Exception& e) {
        Exception* tmp = this;
        while (tmp->next != NULL)
            tmp = tmp->next;
        tmp->next = &e; 
        return *this;
    }
    virtual string show() { return "Classe Exception"; }
    Exception* next;
};
 
// Première exception
class ExceptionA : public Exception {
public:
    virtual std::string show() { return "Classe ExceptionA"; }
};
 
// Seconde exception
class ExceptionB : public Exception {
public:
    virtual std::string show() { return "Classe ExceptionB"; }
};
 
// Affichage;
ostream& operator<<(ostream& out, Exception& e) {
    out << e.show() << endl;
    if (e.next != NULL)
        out << *e.next;
    return out;
}
 
int main(int argc, char *argv[])
{
    // Test d'une exception basique
    try {
        throw ExceptionA();
    } catch (Exception& e) {
        // On attend l'affichage :
        // Class ExceptionA
        cout << "Test simple :" << endl << e << endl;
    }
 
    // Test d'une exception en cascade n°1
    try {
        try {
            throw ExceptionA();
        } catch (Exception& e) {
            ExceptionB b = ExceptionB();
            b.add(e);
            throw b;
        }
    } catch (Exception& e) {
        // On attend l'affichage :
        // Class ExceptionB
        // Class ExceptionA
        cout << "Test cascade n°1 :" << endl << e << endl;
    }
 
    // Test d'une exception en cascade n°2
    try {
        try {
            throw ExceptionA();
        } catch (Exception& e) {
            throw ExceptionB().add(e);
        }
    } catch (Exception& e) {
        // On attend l'affichage :
        // Class ExceptionB
        // Class ExceptionA
        cout << "Test cascade n°2 :" << endl << e << endl;
    }
 
    return 0;
}

Comme vous l'aurez probablement affiché il "foire" au test en cascade n°2 et m'affiche :

Code:

1
2
3
Test cascade n°2 :
Classe Exception
Classe ExceptionA

Vous avez une idée de la raison pour laquelle cela ne fait pas du tout ce que j'attends ? De plus la classe Exception ne sera jamais instanciée, je voulais en faire une classe abstraitre mais cela ne fonctionne pas avec l'envoi d'exceptions :/ c'est la raison pour laquelle j'ai défini la méthode Exception::show()

Merci beaucoup de votre aide.

Nuwanda

22/05/2006, 15h28
Jean-Marc.Bourguet

Citation:

Envoyé par Nuwanda

Vous avez une idée de la raison pour laquelle cela ne fait pas du tout ce que j'attends?

L'objet jete est copie avant d'etre passe au catch. Et la copie se fait avec le type statique de l'objet jete. Le type statique de

Code:

ExceptionB().add(e)

c'est le type du resultat de add(), donc Exception.

Citation:

De plus la classe Exception ne sera jamais instanciée, je voulais en faire une classe abstraitre mais cela ne fonctionne pas avec l'envoi d'exceptions :/

Meme cause. La copie generee ci-dessus est une instantiation.
22/05/2006, 16h05
Nuwanda

Merci beaucoup. J'ai mis un moment à comprendre, mais avec quelques affichage d'addresses mémoire et 2-3 tests j'ai compris pourquoi cela foire. C'est donc le throw qui copie l'objet.

Si l'objet est copié quelle est l'utilité d'avoir le "&" dans le catch ? Vu que l'on ne manipule pas l'objet lancé ?!?!? Donc si on ne met pas le "&" on copie deux fois l'objet ?

Y'a-t-il un moyen de contourner ce problème ? Peut-être en rusant avec le constructeur par copie (mais c'est juste une hypothèse, je ne maitrise pas vraiment ce domaine) ?
22/05/2006, 16h07
Swoög

en effet, à priori, si on ne mets pas le & dans le catch, il y a deux copies...

pour ce qui est de ruser... le seul moyen que je vois semble être de lever en fait un pointeur, alloué avec new, mais c'est pas terrible : il faut le delete, et en plus, c'est même pas sûr qu'un Exception* catch un ExceptionB* ;)
22/05/2006, 16h14
Jean-Marc.Bourguet

Citation:

Envoyé par Nuwanda

Si l'objet est copié quelle est l'utilité d'avoir le "&" dans le catch ?

Ne pas copier une deuxieme fois, ce qui dans le cas present tronquerait tous les objets lances a leur type de base, Exception.

Citation:

Y'a-t-il un moyen de contourner ce problème ? Peut-être en rusant avec le constructeur par copie (mais c'est juste une hypothèse, je ne maitrise pas vraiment ce domaine) ?

Tu veux un comportement polymorphe en meme temps qu'une semantique de copie. Donc il faut jeter un pointeur, eventuellement encapsule pour s'assurer de sa destruction a bon escient.
22/05/2006, 16h18
Jean-Marc.Bourguet

Citation:

Envoyé par Swoög

c'est même pas sûr qu'un Exception* catch un ExceptionB* ;)

Si.
22/05/2006, 16h19
Swoög

Citation:

Envoyé par Jean-Marc.Bourguet

Si.

OK, merci beaucoup :D
22/05/2006, 16h23
Nuwanda

Donc, je viens de faire 2-3 tests...

Si j'ajoute la constructeur par copie dans la classe Exception :

Code:

Exception(const Exception& e) { cout << "Copie de l'objet " << &e << " dans " << this << endl; }

J'obtiens 2 choses intéressantes :
- Quand on ne met pas le "&" dans le catch, on a bien deux copies. (mais c'est pas le plus bizarre)
- Il ne m'affiche que la première exception et pas celle ajoutée à la suite ?!?!?
22/05/2006, 16h26
Jean-Marc.Bourguet

Citation:

Envoyé par Nuwanda

J'obtiens 2 choses intéressantes :
- Quand on ne met pas le "&" dans le catch, on a bien deux copies. (mais c'est pas le plus bizarre)

C'est pas bizarre, c'est attendu.

Citation:

- Il ne m'affiche que la première exception et pas celle ajoutée à la suite ?!?!?

Et le champs next, il est initialise comment? J'ai comme l'impression que par chance il contient un pointeur nul.

Au fait, il manque le clean up de ce qui est alloue dynamiquement.

Merci beaucoup de votre aide à tous, j'ai résolu mon problème en utilisant des pointeurs, ca fonctionne maintenant exactement comme je le souhaite.

Voici le code correspondant :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
#include <iostream>
#include <string>
 
using namespace std;
 
// Classe de base des exceptions
class Exception {
public :
    Exception() : next(NULL) {}
    Exception* add(Exception* e) {
        Exception* tmp = this;
        while (tmp->next != NULL)
            tmp = tmp->next;
        tmp->next = e; 
        return this;
    }
    virtual string show() { return "Classe Exception"; }
    Exception* next;
};
 
// Première exception
class ExceptionA : public Exception {
public:
    virtual string show() { return "Classe ExceptionA"; }
};
 
// Seconde exception
class ExceptionB : public Exception {
public:
    virtual string show() { return "Classe ExceptionB"; }
};
 
// Affichage;
ostream& operator<<(ostream& out, Exception* e) {
    out << e->show() << endl;
    if (e->next != NULL)
        out << e->next;
    return out;
}
 
int main(int argc, char *argv[])
{
    // Test d'une exception basique
    try {
        throw new ExceptionA();
    } catch (Exception*& e) {
        // On attend l'affichage :
        // Class ExceptionA
        cout << "Test simple :" << endl << e << endl;
    }
 
    // Test d'une exception en cascade n°1
    try {
        try {
            throw new ExceptionA();
        } catch (Exception* e) {
            ExceptionB* b = new ExceptionB();
            b->add(e);
            throw b;
        }
    } catch (Exception* e) {
        // On attend l'affichage :
        // Class ExceptionB
        // Class ExceptionA
        cout << "Test cascade n°1 :" << endl << e << endl;
    }
 
    // Test d'une exception en cascade n°2
    try {
        try {
            throw new ExceptionA();
        } catch (Exception* e) {
            throw (new ExceptionB())->add(e);
        }
    } catch (Exception* e) {
        // On attend l'affichage :
        // Class ExceptionB
        // Class ExceptionA
        cout << "Test cascade n°2 :" << endl << e << endl;
    }
 
    return 0;
}

Question subsidiaire : Pourquoi il se mélange les pinceaux entre type réel et type déclaré quand j'utilise les objet, mais quand j'utilise les pointeurs sur objet, il s'en sort parfaitement ?

22/05/2006, 17h32
Swoög

parce qu'il fait une copie de pointeur, c'est à dire qu'il copie "la valeur de l'adresse"

alors que sinon, il copie la valeur de l'objet avec le type courant (dans ce cas Expression puisque ta fonction renvoie un Expression& ;)
22/05/2006, 17h33
Nuwanda

Merci beaucoup !
22/05/2006, 17h44
Jean-Marc.Bourguet
Citation:

Envoyé par Nuwanda

Merci beaucoup de votre aide à tous, j'ai résolu mon problème en utilisant des pointeurs, ca fonctionne maintenant exactement comme je le souhaite.

Voici le code correspondant :

Il a encore des problemes:
1. il se fie au constructeur de copie, a l'operateur d'assignement et au destructeur par defaut pour une classe (Exception) ayant un membre pointeur; ce n'est generalement pas une bonne idee car on ne sait pas qui doit liberer ce pointeur. Dans les rares cas ou c'est adapte, je conseille de mettre un commentaire indiquant que c'est voulu.
2. il y a des allocations de memoire sans liberation (probleme en partie lie au premier mais plus generalement, il n'a pas l'air d'avoir eu de reflexion sur ce probleme).
23/05/2006, 12h06
Nuwanda
Bonjour,

Tout d'abord, je vous remercie de votre interêt pour mon projet ainsi que des éventuels problèmes que je vais renconter.

Il faut savoir que les exceptions qui sont lancées doivent arrêter le logiciel. En effet, je fais un traitement sur des données, si le fichier de données contient des erreurs, je ne peux continuer.

Je dois avouer que pour le moment, ma préocuppation n'est pas de savoir qui doit libérer la mémoire vu que le projet DOIT s'arrêter en cas d'erreur. Je laisse le soin à l'OS de faire la libération de mémoire (il s'agit bien évidemment d'une solution temporaire). Pour le moment, étant donné que le traitement sera très long (plusieurs jours), je me préocuppe principalement de vérifier que l'espace mémoire ne gonfle pas lors du traitement.

Pour la libération de la mémoire des exceptions lorsque celles ci sont reliées, chaque exception supprime la suivante. Théoriquement le code suivant fonctionne comme je le souhaite (enfin j'espère...)
Code:

1 2 3 4 Exception::~Exception() { delete next; }
S'il n'y a pas de suivant, next est à NULL, donc cela s'arrête. De plus le destructeur est virtuel.

Sinon lorsque je vais développer la libération de mémoire, mes données ont une structure arborescente qui fait que chaque élement se chargera de supprimer les suivants et ainsi de suite. J'espère un joli fonctionnement en cascade. Ma seule crainte en réalité vient de la librairie que j'utilise et j'espère qu'elle n'a pas trop de fuites mémoires...

Bonne journée !