Discussion :

[Bouteille]

Bonjour,

Une fois de plus je viens demander votre aide...
Je suis en ce moment en train de developper une petite classe derivant de exception pour gerer les erreurs dans mon programme.

Cependant j'aimerai creer une fonction membre de cette classe qui serait appelée dans le catch et qui me permettrait de gerer le traitement de cette erreur.
Je voudrai pouvoir gerer 3 cas : creer une exception qui va relancer l'exception (throw(this)), creer une exception qui va continuer l'execution du programme (rien a faire dans ce cas, le programme continue apres le catch), et une autre qui va reessayer le code precedent (revenir dans le debut du try).

Le comportement (les 3 cas) sera defini par une donnée membre (m_type) qui aura ete initialisé a une valeur lors de la creation de l'objet exception.

bref, ca donne quelque chose comme ca :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
#include <iostream>
#include <sstream>
#include <exception>
 
 
#define EXC_CONTINUE	1
#define EXC_ABORT	2
#define EXC_ASK		3
 
 
class CMyException : public exception
{
    private:
 
	short m_type;
 
    public:
 
	CMyException(const string message, const short type=EXC_ASK)
	:m_type(type)
	{
		std::ostringstream oss;
		oss << "ERROR : " << message;
		msg = oss.str();
	}
 
 
 
	virtual ~CMyException() throw()
	{}
 
	virtual const char* what() const throw()
	{
		return msg.c_str();
	}
 
	void eval()
	{
		switch(m_type)
		{
			case EXC_CONTINUE:
				break;
 
			case EXC_ABORT:
				throw(this);
 
			case EXC_RETRY:
				// ???
				break;
 
			case EXC_ASK:
				// a faire
				break;
 
		}
	}
 
	int getType() { return m_type; }
 
	void setType(int type) { m_type=type; }
 
};

Voila, le probleme vient de la fonction eval... Je ne sais deja pas si elle a quelque chose a faire dans la classe CMyException...
Ensuite je ne suis pas sur de sa pertinence notamment pour le cas retry que je ne sais pas du tout gerer... Il me faudrait un moyen de retourner dans le try... une fonction retry...
Ou alors un goto... non c'est pour rire c mal le goto mais il y a surement un defaut de conception derriere tout ca et je ne sais pas trop comment gerer ca...

Si vous avez un indice ca serait super merci !!!

@ bientot.

[Bouteille]

Une boucle contenant le try catch controlée par un boolen qui serait modifié (passage par adresse) lors de la fonction eval... ?
Ca parait tordu mais il se fait tard...

[3DArchi]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
#define EXC_CONTINUE	1
#define EXC_ABORT	2
#define EXC_ASK		3

Tu connais les enum ou au - les constantes ?
Sinon, je pense que ton défaut de conception est de vouloir mettre dans l'exception une partie de son traitement. Ce que tu veux faire devrait être fait dans le traitement de l'exception et non par l'exception.

[Bouteille]

Ok les enums je m'y met pas bete ! Merci pour le conseil... j'apprends.

D'accord donc d'apres toi ca ne sert a rien que j'essaye d'encapsuler cela dans mes propres methodes (et surtout pas dans mon exception) et il vaut mieux faire ca traditionnellement au cas par cas (des try catchs avec du code dedans quoi )... Je pense laisser tomber la fonction "quifaittout"...

Je me demandais surtout si il y avait un schema classique pour faire un retry ou pour arriver a faire ce que j'essaye de faire avec ma fonction... Une piste ?

Merci.

[koala01]

Salut,

Un schéma un peu crade mais qui fonctionne pourrait être

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void foo()
{
    /* ce qui ne doit être fait qu'une fois au début */
    begin:
    try
    {
         laFonctionQuiRisqueDeRater();
    }
    catch(MonException & e)
    {
        /* gestion de l'erreur */
        goto begin;
    }
    /* ce qui ne doit être fait qu'une fois à la fin */
}

Si je dis que le schéma est un peu crade, c'est à cause de la présence du goto... que l'on cherche généralement à éviter autant que possible.

Il existe donc une solution plus "propre" qui utiliserait les boucles sous une forme proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
void foo()
{
    /* ce qui ne doit être fait qu'une fois au début */
    bool again=false; /* on considère que la première fois marchera */
    do
    {
        try
        {
             laFonctionQuiRisqueDeRater();
        }
        catch(MonException & e)
        {
            /* gestion de l'erreur */
            /* si on arrive ici, il faut recommencer... */
            again = true;
        }
    }while(again==false);
    /* ce qui ne doit être fait qu'à la fin */
}

mais qui ajoute un niveau d'indentation...

Si la logique à effectuer dans la boucle est elle-même déjà complexe et nécessite plusieurs niveaux d'indentation, le code effectif risque de finir par se retrouver "dans les matitis"

[Bouteille]

Ok, je te remercie pour ce bout de code, ca correspond a peu pres a ce que je pensais faire.
Je vais essayer de voir si je peux me faire une fonction qui me permet de faire ca de facon transparente.

D'ailleurs ca m'a mené a discuter avec un ami du probleme du goto... Si on met l'etiquette dans le try au tout debut, que va-t-il se passer a l'execution ? Le programe "saura"-t-il qu'il est dans le bloc try ? plantage ?