Salut,
En regardant quelques discussion intéressante sur la meilleure façon de
gérer les erreurs dans un programme C++ ici :
http://damienkatz.net/2006/04/error_code_vs_e.html
Je suis tombé sur la proposition suivante pour ne pas avoir à choisir au
moment de l'écriture d'une fonction si elle sera gérée avce un code
d'erreur ou une exception :
"There is a way to let the caller make the decision of code vs.
exception. I wrote a class that can be returned just like an error code,
but it automatically throws an exception if its status isn't checked. It
allowed us to convert an entire library written with an error code
paradigm, to optionally use exceptions instead."
En fait c'est hyper simple à faire, je me demande ce que vous pensez de
cette technique ?
[snip]
Salut,
En regardant quelques discussion intéressante sur la meilleure façon de
gérer les erreurs dans un programme C++ ici :
http://damienkatz.net/2006/04/error_code_vs_e.html
Je suis tombé sur la proposition suivante pour ne pas avoir à choisir au
moment de l'écriture d'une fonction si elle sera gérée avce un code
d'erreur ou une exception :
"There is a way to let the caller make the decision of code vs.
exception. I wrote a class that can be returned just like an error code,
but it automatically throws an exception if its status isn't checked. It
allowed us to convert an entire library written with an error code
paradigm, to optionally use exceptions instead."
En fait c'est hyper simple à faire, je me demande ce que vous pensez de
cette technique ?
[snip]
Salut,
En regardant quelques discussion intéressante sur la meilleure façon de
gérer les erreurs dans un programme C++ ici :
http://damienkatz.net/2006/04/error_code_vs_e.html
Je suis tombé sur la proposition suivante pour ne pas avoir à choisir au
moment de l'écriture d'une fonction si elle sera gérée avce un code
d'erreur ou une exception :
"There is a way to let the caller make the decision of code vs.
exception. I wrote a class that can be returned just like an error code,
but it automatically throws an exception if its status isn't checked. It
allowed us to convert an entire library written with an error code
paradigm, to optionally use exceptions instead."
En fait c'est hyper simple à faire, je me demande ce que vous pensez de
cette technique ?
[snip]
Salut,
En regardant quelques discussion intéressante sur la meilleure façon de
gérer les erreurs dans un programme C++ ici :http://damienkatz.net/2006 /04/error_code_vs_e.html
Je suis tombé sur la proposition suivante pour ne pas avoir à choisir au
moment de l'écriture d'une fonction si elle sera gérée avce un code
d'erreur ou une exception :
"There is a way to let the caller make the decision of code vs.
exception. I wrote a class that can be returned just like an error code,
but it automatically throws an exception if its status isn't checked. It
allowed us to convert an entire library written with an error code
paradigm, to optionally use exceptions instead."
En fait c'est hyper simple à faire, je me demande ce que vous pensez de
cette technique ?
Illustration à la suite :
<snip>
Salut,
En regardant quelques discussion intéressante sur la meilleure façon de
gérer les erreurs dans un programme C++ ici :http://damienkatz.net/2006 /04/error_code_vs_e.html
Je suis tombé sur la proposition suivante pour ne pas avoir à choisir au
moment de l'écriture d'une fonction si elle sera gérée avce un code
d'erreur ou une exception :
"There is a way to let the caller make the decision of code vs.
exception. I wrote a class that can be returned just like an error code,
but it automatically throws an exception if its status isn't checked. It
allowed us to convert an entire library written with an error code
paradigm, to optionally use exceptions instead."
En fait c'est hyper simple à faire, je me demande ce que vous pensez de
cette technique ?
Illustration à la suite :
<snip>
Salut,
En regardant quelques discussion intéressante sur la meilleure façon de
gérer les erreurs dans un programme C++ ici :http://damienkatz.net/2006 /04/error_code_vs_e.html
Je suis tombé sur la proposition suivante pour ne pas avoir à choisir au
moment de l'écriture d'une fonction si elle sera gérée avce un code
d'erreur ou une exception :
"There is a way to let the caller make the decision of code vs.
exception. I wrote a class that can be returned just like an error code,
but it automatically throws an exception if its status isn't checked. It
allowed us to convert an entire library written with an error code
paradigm, to optionally use exceptions instead."
En fait c'est hyper simple à faire, je me demande ce que vous pensez de
cette technique ?
Illustration à la suite :
<snip>
Salut,
En regardant quelques discussion intéressante sur la meilleure façon de
gérer les erreurs dans un programme C++ ici :
http://damienkatz.net/2006/04/error_code_vs_e.html
Je suis tombé sur la proposition suivante pour ne pas avoir à choisir au
moment de l'écriture d'une fonction si elle sera gérée avce un code
d'erreur ou une exception :
"There is a way to let the caller make the decision of code vs.
exception. I wrote a class that can be returned just like an error code,
but it automatically throws an exception if its status isn't checked. It
allowed us to convert an entire library written with an error code
paradigm, to optionally use exceptions instead."
En fait c'est hyper simple à faire, je me demande ce que vous pensez de
cette technique ?
Salut,
En regardant quelques discussion intéressante sur la meilleure façon de
gérer les erreurs dans un programme C++ ici :
http://damienkatz.net/2006/04/error_code_vs_e.html
Je suis tombé sur la proposition suivante pour ne pas avoir à choisir au
moment de l'écriture d'une fonction si elle sera gérée avce un code
d'erreur ou une exception :
"There is a way to let the caller make the decision of code vs.
exception. I wrote a class that can be returned just like an error code,
but it automatically throws an exception if its status isn't checked. It
allowed us to convert an entire library written with an error code
paradigm, to optionally use exceptions instead."
En fait c'est hyper simple à faire, je me demande ce que vous pensez de
cette technique ?
Salut,
En regardant quelques discussion intéressante sur la meilleure façon de
gérer les erreurs dans un programme C++ ici :
http://damienkatz.net/2006/04/error_code_vs_e.html
Je suis tombé sur la proposition suivante pour ne pas avoir à choisir au
moment de l'écriture d'une fonction si elle sera gérée avce un code
d'erreur ou une exception :
"There is a way to let the caller make the decision of code vs.
exception. I wrote a class that can be returned just like an error code,
but it automatically throws an exception if its status isn't checked. It
allowed us to convert an entire library written with an error code
paradigm, to optionally use exceptions instead."
En fait c'est hyper simple à faire, je me demande ce que vous pensez de
cette technique ?
Après, faudrait aussi vérfier dans la norme la possibilité de lancer
une exception dans un destructeur.
Après, faudrait aussi vérfier dans la norme la possibilité de lancer
une exception dans un destructeur.
Après, faudrait aussi vérfier dans la norme la possibilité de lancer
une exception dans un destructeur.
Marc Boyer wrote:Après, faudrait aussi vérfier dans la norme la possibilité de lancer
une exception dans un destructeur.
'Fectivement, bien que cela ne soit totalement interdit ça peut poser de
gros problèmes :-), cd http://www.gotw.ca/gotw/047.htm pour les détails
Marc Boyer wrote:
Après, faudrait aussi vérfier dans la norme la possibilité de lancer
une exception dans un destructeur.
'Fectivement, bien que cela ne soit totalement interdit ça peut poser de
gros problèmes :-), cd http://www.gotw.ca/gotw/047.htm pour les détails
Marc Boyer wrote:Après, faudrait aussi vérfier dans la norme la possibilité de lancer
une exception dans un destructeur.
'Fectivement, bien que cela ne soit totalement interdit ça peut poser de
gros problèmes :-), cd http://www.gotw.ca/gotw/047.htm pour les détails
Salut,
En regardant quelques discussion intéressante sur la meilleure façon de
gérer les erreurs dans un programme C++ ici :
http://damienkatz.net/2006/04/error_code_vs_e.html
Je suis tombé sur la proposition suivante pour ne pas avoir à choisir au
moment de l'écriture d'une fonction si elle sera gérée avce un code
d'erreur ou une exception :
"There is a way to let the caller make the decision of code vs.
exception. I wrote a class that can be returned just like an error code,
but it automatically throws an exception if its status isn't checked. It
allowed us to convert an entire library written with an error code
paradigm, to optionally use exceptions instead."
En fait c'est hyper simple à faire, je me demande ce que vous pensez de
cette technique ?
Illustration à la suite :
include <iostream>
class ErrorValue {
int rv;
bool checked;
public:
ErrorValue(int v): rv(v), checked(false) {}
~ErrorValue() {if (checked=úlse) throw *this;}
operator int() {checked=true;return rv;}
};
ErrorValue test1 () {
return ErrorValue(1);
}
ErrorValue test2 () {
return ErrorValue(2);
}
int main(int argc, char * argv[]) {
try {
int rc = test1();
std::cout << "Return ErrorValue of first test is "
<< rc << "n";
test2();
} catch (ErrorValue &ev) {
std::cout << "ErrorValue catched is "
<< ev << "n" ;
}
}
PS : Avec cette écriture, il y a quand même un petit piège potentiel,
qu'on retrouve dans ma première version avec "catch (ErrorValue ev)" où
le programme ne se terminait pas très bien, pe que "throw rv" serait
plus raisonnable ou bien contruire un type qui n'est pas vérifié pour ce
throw.
Salut,
En regardant quelques discussion intéressante sur la meilleure façon de
gérer les erreurs dans un programme C++ ici :
http://damienkatz.net/2006/04/error_code_vs_e.html
Je suis tombé sur la proposition suivante pour ne pas avoir à choisir au
moment de l'écriture d'une fonction si elle sera gérée avce un code
d'erreur ou une exception :
"There is a way to let the caller make the decision of code vs.
exception. I wrote a class that can be returned just like an error code,
but it automatically throws an exception if its status isn't checked. It
allowed us to convert an entire library written with an error code
paradigm, to optionally use exceptions instead."
En fait c'est hyper simple à faire, je me demande ce que vous pensez de
cette technique ?
Illustration à la suite :
include <iostream>
class ErrorValue {
int rv;
bool checked;
public:
ErrorValue(int v): rv(v), checked(false) {}
~ErrorValue() {if (checked=úlse) throw *this;}
operator int() {checked=true;return rv;}
};
ErrorValue test1 () {
return ErrorValue(1);
}
ErrorValue test2 () {
return ErrorValue(2);
}
int main(int argc, char * argv[]) {
try {
int rc = test1();
std::cout << "Return ErrorValue of first test is "
<< rc << "n";
test2();
} catch (ErrorValue &ev) {
std::cout << "ErrorValue catched is "
<< ev << "n" ;
}
}
PS : Avec cette écriture, il y a quand même un petit piège potentiel,
qu'on retrouve dans ma première version avec "catch (ErrorValue ev)" où
le programme ne se terminait pas très bien, pe que "throw rv" serait
plus raisonnable ou bien contruire un type qui n'est pas vérifié pour ce
throw.
Salut,
En regardant quelques discussion intéressante sur la meilleure façon de
gérer les erreurs dans un programme C++ ici :
http://damienkatz.net/2006/04/error_code_vs_e.html
Je suis tombé sur la proposition suivante pour ne pas avoir à choisir au
moment de l'écriture d'une fonction si elle sera gérée avce un code
d'erreur ou une exception :
"There is a way to let the caller make the decision of code vs.
exception. I wrote a class that can be returned just like an error code,
but it automatically throws an exception if its status isn't checked. It
allowed us to convert an entire library written with an error code
paradigm, to optionally use exceptions instead."
En fait c'est hyper simple à faire, je me demande ce que vous pensez de
cette technique ?
Illustration à la suite :
include <iostream>
class ErrorValue {
int rv;
bool checked;
public:
ErrorValue(int v): rv(v), checked(false) {}
~ErrorValue() {if (checked=úlse) throw *this;}
operator int() {checked=true;return rv;}
};
ErrorValue test1 () {
return ErrorValue(1);
}
ErrorValue test2 () {
return ErrorValue(2);
}
int main(int argc, char * argv[]) {
try {
int rc = test1();
std::cout << "Return ErrorValue of first test is "
<< rc << "n";
test2();
} catch (ErrorValue &ev) {
std::cout << "ErrorValue catched is "
<< ev << "n" ;
}
}
PS : Avec cette écriture, il y a quand même un petit piège potentiel,
qu'on retrouve dans ma première version avec "catch (ErrorValue ev)" où
le programme ne se terminait pas très bien, pe que "throw rv" serait
plus raisonnable ou bien contruire un type qui n'est pas vérifié pour ce
throw.
En regardant quelques discussion intéressante sur la meilleure façon de
gérer les erreurs dans un programme C++ ici :
http://damienkatz.net/2006/04/error_code_vs_e.html
Je suis tombé sur la proposition suivante pour ne pas avoir à choisir au
moment de l'écriture d'une fonction si elle sera gérée avce un code
d'erreur ou une exception :
"There is a way to let the caller make the decision of code vs.
exception. I wrote a class that can be returned just like an error code,
but it automatically throws an exception if its status isn't checked. It
allowed us to convert an entire library written with an error code
paradigm, to optionally use exceptions instead."
En fait c'est hyper simple à faire, je me demande ce que vous pensez de
cette technique ?
Illustration à la suite :
include <iostream>
class ErrorValue {
int rv;
bool checked;
public:
ErrorValue(int v): rv(v), checked(false) {}
~ErrorValue() {if (checked=úlse) throw *this;}
operator int() {checked=true;return rv;}
};
En regardant quelques discussion intéressante sur la meilleure façon de
gérer les erreurs dans un programme C++ ici :
http://damienkatz.net/2006/04/error_code_vs_e.html
Je suis tombé sur la proposition suivante pour ne pas avoir à choisir au
moment de l'écriture d'une fonction si elle sera gérée avce un code
d'erreur ou une exception :
"There is a way to let the caller make the decision of code vs.
exception. I wrote a class that can be returned just like an error code,
but it automatically throws an exception if its status isn't checked. It
allowed us to convert an entire library written with an error code
paradigm, to optionally use exceptions instead."
En fait c'est hyper simple à faire, je me demande ce que vous pensez de
cette technique ?
Illustration à la suite :
include <iostream>
class ErrorValue {
int rv;
bool checked;
public:
ErrorValue(int v): rv(v), checked(false) {}
~ErrorValue() {if (checked==false) throw *this;}
operator int() {checked=true;return rv;}
};
En regardant quelques discussion intéressante sur la meilleure façon de
gérer les erreurs dans un programme C++ ici :
http://damienkatz.net/2006/04/error_code_vs_e.html
Je suis tombé sur la proposition suivante pour ne pas avoir à choisir au
moment de l'écriture d'une fonction si elle sera gérée avce un code
d'erreur ou une exception :
"There is a way to let the caller make the decision of code vs.
exception. I wrote a class that can be returned just like an error code,
but it automatically throws an exception if its status isn't checked. It
allowed us to convert an entire library written with an error code
paradigm, to optionally use exceptions instead."
En fait c'est hyper simple à faire, je me demande ce que vous pensez de
cette technique ?
Illustration à la suite :
include <iostream>
class ErrorValue {
int rv;
bool checked;
public:
ErrorValue(int v): rv(v), checked(false) {}
~ErrorValue() {if (checked=úlse) throw *this;}
operator int() {checked=true;return rv;}
};
En regardant quelques discussion intéressante sur la meilleure faço n de
gérer les erreurs dans un programme C++ ici :
http://damienkatz.net/2006/04/error_code_vs_e.html
Je suis tombé sur la proposition suivante pour ne pas avoir à chois ir au
moment de l'écriture d'une fonction si elle sera gérée avce un co de
d'erreur ou une exception :
"There is a way to let the caller make the decision of code vs.
exception. I wrote a class that can be returned just like an error code,
but it automatically throws an exception if its status isn't checked. It
allowed us to convert an entire library written with an error code
paradigm, to optionally use exceptions instead."
En fait c'est hyper simple à faire, je me demande ce que vous pensez de
cette technique ?
[snip]
Au lieu de jeter l'exception dans un destructeur, je préférerais deux
méthodes me permettant de choisir l'une ou l'autre solution (Si
l'utilisateur ne check pas le retour de la fonction; il a le droit de ne
pas s'y intéresser.) et je préférerais ne pas lancer une exception
systématiquement.
Sinon, jeter une exception dans un destructeur pose la question de
savoir ce qu'il advient de la mémoire (comment est implémenté le de lete)
donc il y une forte chance que ce ne soit pas portable à moins de
l'overloader.
En regardant quelques discussion intéressante sur la meilleure faço n de
gérer les erreurs dans un programme C++ ici :
http://damienkatz.net/2006/04/error_code_vs_e.html
Je suis tombé sur la proposition suivante pour ne pas avoir à chois ir au
moment de l'écriture d'une fonction si elle sera gérée avce un co de
d'erreur ou une exception :
"There is a way to let the caller make the decision of code vs.
exception. I wrote a class that can be returned just like an error code,
but it automatically throws an exception if its status isn't checked. It
allowed us to convert an entire library written with an error code
paradigm, to optionally use exceptions instead."
En fait c'est hyper simple à faire, je me demande ce que vous pensez de
cette technique ?
[snip]
Au lieu de jeter l'exception dans un destructeur, je préférerais deux
méthodes me permettant de choisir l'une ou l'autre solution (Si
l'utilisateur ne check pas le retour de la fonction; il a le droit de ne
pas s'y intéresser.) et je préférerais ne pas lancer une exception
systématiquement.
Sinon, jeter une exception dans un destructeur pose la question de
savoir ce qu'il advient de la mémoire (comment est implémenté le de lete)
donc il y une forte chance que ce ne soit pas portable à moins de
l'overloader.
En regardant quelques discussion intéressante sur la meilleure faço n de
gérer les erreurs dans un programme C++ ici :
http://damienkatz.net/2006/04/error_code_vs_e.html
Je suis tombé sur la proposition suivante pour ne pas avoir à chois ir au
moment de l'écriture d'une fonction si elle sera gérée avce un co de
d'erreur ou une exception :
"There is a way to let the caller make the decision of code vs.
exception. I wrote a class that can be returned just like an error code,
but it automatically throws an exception if its status isn't checked. It
allowed us to convert an entire library written with an error code
paradigm, to optionally use exceptions instead."
En fait c'est hyper simple à faire, je me demande ce que vous pensez de
cette technique ?
[snip]
Au lieu de jeter l'exception dans un destructeur, je préférerais deux
méthodes me permettant de choisir l'une ou l'autre solution (Si
l'utilisateur ne check pas le retour de la fonction; il a le droit de ne
pas s'y intéresser.) et je préférerais ne pas lancer une exception
systématiquement.
Sinon, jeter une exception dans un destructeur pose la question de
savoir ce qu'il advient de la mémoire (comment est implémenté le de lete)
donc il y une forte chance que ce ne soit pas portable à moins de
l'overloader.
Après, faudrait aussi vérfier dans la norme la possibilité de lan cer
une exception dans un destructeur.
Après, faudrait aussi vérfier dans la norme la possibilité de lan cer
une exception dans un destructeur.
Après, faudrait aussi vérfier dans la norme la possibilité de lan cer
une exception dans un destructeur.
Michael DOUBEZ wrote:En regardant quelques discussion intéressante sur la meilleure façon de
gérer les erreurs dans un programme C++ ici :
http://damienkatz.net/2006/04/error_code_vs_e.html
Je suis tombé sur la proposition suivante pour ne pas avoir à choisir au
moment de l'écriture d'une fonction si elle sera gérée avce un code
d'erreur ou une exception :
"There is a way to let the caller make the decision of code vs.
exception. I wrote a class that can be returned just like an error code,
but it automatically throws an exception if its status isn't checked. It
allowed us to convert an entire library written with an error code
paradigm, to optionally use exceptions instead."
En fait c'est hyper simple à faire, je me demande ce que vous pensez de
cette technique ?
[snip]
Sinon, jeter une exception dans un destructeur pose la question de
savoir ce qu'il advient de la mémoire (comment est implémenté le delete)
donc il y une forte chance que ce ne soit pas portable à moins de
l'overloader.
Je ne comprends pas le problème ici. Il n'y a pas de delete. À
la rigueur, il pourrait déclarer un operator delete privé dans
la classe, afin de le garantir, mais dans la pratique, je crois
que la risque qu'un utilisateur fasse de l'allocation dynamique
d'une telle classe est assez faible.
Michael DOUBEZ wrote:
En regardant quelques discussion intéressante sur la meilleure façon de
gérer les erreurs dans un programme C++ ici :
http://damienkatz.net/2006/04/error_code_vs_e.html
Je suis tombé sur la proposition suivante pour ne pas avoir à choisir au
moment de l'écriture d'une fonction si elle sera gérée avce un code
d'erreur ou une exception :
"There is a way to let the caller make the decision of code vs.
exception. I wrote a class that can be returned just like an error code,
but it automatically throws an exception if its status isn't checked. It
allowed us to convert an entire library written with an error code
paradigm, to optionally use exceptions instead."
En fait c'est hyper simple à faire, je me demande ce que vous pensez de
cette technique ?
[snip]
Sinon, jeter une exception dans un destructeur pose la question de
savoir ce qu'il advient de la mémoire (comment est implémenté le delete)
donc il y une forte chance que ce ne soit pas portable à moins de
l'overloader.
Je ne comprends pas le problème ici. Il n'y a pas de delete. À
la rigueur, il pourrait déclarer un operator delete privé dans
la classe, afin de le garantir, mais dans la pratique, je crois
que la risque qu'un utilisateur fasse de l'allocation dynamique
d'une telle classe est assez faible.
Michael DOUBEZ wrote:En regardant quelques discussion intéressante sur la meilleure façon de
gérer les erreurs dans un programme C++ ici :
http://damienkatz.net/2006/04/error_code_vs_e.html
Je suis tombé sur la proposition suivante pour ne pas avoir à choisir au
moment de l'écriture d'une fonction si elle sera gérée avce un code
d'erreur ou une exception :
"There is a way to let the caller make the decision of code vs.
exception. I wrote a class that can be returned just like an error code,
but it automatically throws an exception if its status isn't checked. It
allowed us to convert an entire library written with an error code
paradigm, to optionally use exceptions instead."
En fait c'est hyper simple à faire, je me demande ce que vous pensez de
cette technique ?
[snip]
Sinon, jeter une exception dans un destructeur pose la question de
savoir ce qu'il advient de la mémoire (comment est implémenté le delete)
donc il y une forte chance que ce ne soit pas portable à moins de
l'overloader.
Je ne comprends pas le problème ici. Il n'y a pas de delete. À
la rigueur, il pourrait déclarer un operator delete privé dans
la classe, afin de le garantir, mais dans la pratique, je crois
que la risque qu'un utilisateur fasse de l'allocation dynamique
d'une telle classe est assez faible.