Discussion :

[mister3957]

Bonjour à tous,

J'aimerai faire ma gestion d'erreur autour des exceptions. Je possède une classe de conversion et voici son code:

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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
// Code d'une fonction dans ma classe de conversion
void CConverter::ToInt(const char* sIn, int& iOut)
{
	try
	{
		iOut = lexical_cast<int>(sIn);
	}
	catch(std::exception)
	{
		throw new CConvertException("const char*", "int&", sIn);
	}
}
 
// Code de la fonction appelante
try
{
	CConverter::Instance().ToInt(sString.c_str(), iValue);
}
catch(CConvertException ex)
{
	LogManager::Instance() << ex.What();
}
 
// Classe de CConvertException
#include "../../Exception/CException.h"
 
namespace kin
{
	namespace utils
	{
		namespace conversion
		{
			namespace exceptions
			{
				class CConvertException : public kin::utils::exception::CException
				{
				public:
					CConvertException(
						const std::string& sFromType,
						const std::string& sToType,
						const std::string& sValue,
						const std::string& sMessage = "Conversion impossible.");
				};
			};
		};
	};
};
 
// Classe CException
#include <exception>
#include <string>
#include <vector>
#include <map>
 
namespace kin
{
	namespace utils
	{
		namespace exception
		{
			class CException : public std::exception
			{
			public :
				CException(const std::string& sMessage, CException* oOriginException = NULL);
				CException* GetOriginException();
				const char* what() const throw();
 
			protected :
				std::string m_sMessage;
				void AddCause(const char* sCause);
				void AddParam(const char* sKey, const char*sValue);
 
			private:
				std::vector<const char*> m_oCauseVector;
				std::map<const char*, const char*> m_oParamMap;
				CException* m_oOriginException;
			};
		};
	};
};

Voilà, lors du "throw", ça me renvoi une exception non géré, alors que l'appelle de celle-ci est entouré d'un try/catch :s

Donc je ne comprends pas, CException dérive de std::exception, et CConvertException dérive de CException, le catch "attrape" bien les exception de type CConvertException...

Quelqu'un peut m'éclairer?

Merci beaucoup

A bientôt

[Laurent Gomila]

Et en attrapant ton std::exception par référence ?

[mister3957]

Merci

J'ai mis catch(std::exception& ex) et c'est pareil (unhandle exception) :'(

[mister3957]

Ha c'est bon, j'suis bête, fallait mettre catch(CConvertException* ex) vu que je lance le throw avec un new derrière...

Merci beaucoup

[Laurent Gomila]

Ah oui... Quelle idée d'allouer une exception dynamiquement

Enfin si tu y tiens, tu peux tout de même attraper un std::exception*

[mister3957]

Bah c'est la première fois que je fais ça...

En général on fait ça comment?

merci

[Matthieu Brucher]

En général, on récupère un "const MonException& exception"

[mister3957]

Ok merci beaucoup, j'essaye

[Luc Hermitte]

En général on fait ça comment?

"throw by value, catch by reference"

[zais_ethael]

Petite question, pourquoi tu crées ta propre classe d'exception alors qu'il y en a déja une pour la fonction lexical_cast? (lexical_cast_exception ou quelque chose qui y ressemble)
Autre chose, c'est moyen moyen de dériver de std::exception, ça t'oblige à taper une bonne partie de code supplémentaire car ce n'est pas le but de cette classe que l'utilisateur l'utilise directement. Idéalement, il faut faire dériver de std::logic_exception ou bien de std::runtime_exception (probablement runtime_exception dans ce cas) qui dérivent chacune de std::exception.

[mister3957]

C'est pour transformer la lexical_cast_exception.

Ainsi, une lexical_cast_exception donnera lieu à une CConvertException qui elle donnera lieu à une CConfigBadCastException.

Dans chaque exception, j'ai réussit à en référencer une autre, et maintenant je peux voir tous les niveaux. Pour l'exemple ci dessus j'aurai:

Code :

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

1
2
3
4
 
"Impossible de récupérer une valeur dans le fichier de configuration
    Origine:
        Impossible de convertir une valeur".

J'ai rajouté également une liste de paramètre et de cause dans les exception. Comme ça, dans le constructeur de chaque classe, on peut spécifier des paramètres qui seront donné lors de lancement.

Le what renvoi juste le message, et j'ai rajouter une methode FullMessage qui me permet de formatter un beau message en prenant en compte les paramètres, les causes ainsi que l'eventuelle origine.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
"Impossible de récupérer une valeur dans le fichier de configuration
    Causes possibles:
        - Le fichier de configuration n'est pas correctement formatté
        - Une autre cause possible
        - Et enfin une dernière
    Paramètres:
        - Clé : 'i'
    Origine:
        Impossible de convertir 'n' en integer.
            Paramètres:
                - Valeur : 'n'
                - Type : string
                - Cast : int"

Et ainsi de suite.

Grâce à ça, je peux remonter les problèmes jusqu'à la source et tous mes message d'exceptions sont homogènes car leur construction est dans la classe de base. J'ai casiment plus besoin de relancer le programme en mode débug jusqu'à l'exception car je sais d'emblée où elle se trouve.

J'espère que c'est bien ce que j'ai fait, peut être il faudrait rajouter la ligne et le fichier avec les __LINE__ et __FILE__ pour mieux la situer...

Quand je vois, dans mon boulot, les messages que rencontrent les utilisateurs... la hotline ne peux rien faire, on est sans cesse en train de leur demander de nous renvoyer tout le répertoire d'installation, les clés dans la base de registre pour relancer chez nous jusqu'à ce que ça plante...

[Matthieu Brucher]

Autre chose, c'est moyen moyen de dériver de std::exception, ça t'oblige à taper une bonne partie de code supplémentaire car ce n'est pas le but de cette classe que l'utilisateur l'utilise directement. Idéalement, il faut faire dériver de std::logic_exception ou bien de std::runtime_exception (probablement runtime_exception dans ce cas) qui dérivent chacune de std::exception.

std::exception donne un what() qui est virtuel et surchargé dans toutes les autres exceptions standards ou presque - comme runtime_error, bad_alloc, ... -, donc pas de pb de dériver de std::exception. Mais il y a une hiérarchie d'exception qu'il faut essayer de respecter par logique.

[zais_ethael]

Oui mais il ne contient pas de std::string en interne et pas non plus de constructeur prenant un string en argument (sauf dans visual studio d'après ce que j'ai pu voir - ce qui peut-être une cause de non-portabilité).
Mais l'interet principal est bien sur de respecter la hiérarchie

[mister3957]

Au départ je voulais générer le message dans le what().

Mais j'ai pas réussit. En effet, pour les concaténation, je me suis appyué sur std::string. Mais le what renvoir un char*, alors je faisais return sWhat.c_str().

Sauf qu'une fois le what() passé, la std::string n'existe plus, et donc la valeur de retour non plus.

J'ai bien essayé de recréer un char*, mais çame faisais faire un new dans la fonction que chaque catch derrière devait supprimer, et j'ai trouvé ça vraiment pas bon.

Autre chose, si on cherche à afficher le message différemment, on voidra peut-être parcourir les exceptions pour accéder aux informations librement dans être cantonné à ce message formatté, donc j'ai trouvé plus utile pour la suite de dissocier le message initiale, les paramètres et les causes du message formatté.

Imaginez que je voudrais afficher ça dans un treeview, bah si je ne propose qu'un texte pré formatté, on pourra rien faire, donc je propose tout

J'pense que j'suis dans le bon là.