Je m'explique : y-a-t-il un moyen que tout le monde connait sauf moi de
savoir si une opération sur des entiers (par exemple) va provoquer un
"dépassement" de valeur limite , ou doit-on le tester avant chaque
opération, comme ceci par exemple, pour une multiplication ?
int max_value=std::numeric_limits<int>().max();
int x=...,y=...; // valeurs dans les limites au départ
int produit;
if (y>(max_value/x)) throw ExceptionDepassement(); // division entiere
else produit=x*y; // pas de dépassement ici
Comme j'ai redéfini des classes pour les différents types fondamentaux,
est-il légitime d'envisager d'introduire ces tests de dépassement dans les
opérateurs redéfinis (reste ensuite le pb de la vitesse d'exécution...) ?
Marc
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Pierre Maurette
"Marc" a écrit:
Je m'explique : y-a-t-il un moyen que tout le monde connait sauf moi de savoir si une opération sur des entiers (par exemple) va provoquer un "dépassement" de valeur limite , ou doit-on le tester avant chaque opération, comme ceci par exemple, pour une multiplication ?
int max_value=std::numeric_limits<int>().max(); int x=...,y=...; // valeurs dans les limites au départ int produit; if (y>(max_value/x)) throw ExceptionDepassement(); // division entiere else produit=x*y; // pas de dépassement ici Comme j'ai redéfini des classes pour les différents types fondamentaux, est-il légitime d'envisager d'introduire ces tests de dépassement dans les opérateurs redéfinis (reste ensuite le pb de la vitesse d'exécution...) ? Je ne pense pas qu'il existe une réponse positive à votre problème. Ou
alors dans des bibliothèques non standards ou dans les spécifics de l'implémentation.
Je ne le crois pas d'abord parce que les quelques sources que je connais sur des classes grands entiers utilisent l'assembleur. De plus, il semble que ce bout de littérature C# fournisse une réponse: http://www.thecodeproject.com/csharp/overflow_checking.asp
Si vous savez disposer d'un type entier faisant 2*siezof(int), vous pourriez peut-être envisager une autre approche: multiplier dans ce type et tester la partie haute du résultat. Ça ouvre d'autres perspectives, que vous pouvez ou non exploiter (une addition dépasse de 1 ou ne dépasse pas, ce qui n'est pas le cas de la multiplication). Remarque: les processeurs Intel family (et pourquoi pas d'autres) mènent la multiplication entière de cette façon. Il est donc permis d'espérer qu'un compilateur pas trop tarte optimise intelligemment et que ce soit aussi bon, voire meilleur, que le test préalable. -- Pierre
"Marc" <metrica@free.fr> a écrit:
Je m'explique : y-a-t-il un moyen que tout le monde connait sauf moi de
savoir si une opération sur des entiers (par exemple) va provoquer un
"dépassement" de valeur limite , ou doit-on le tester avant chaque
opération, comme ceci par exemple, pour une multiplication ?
int max_value=std::numeric_limits<int>().max();
int x=...,y=...; // valeurs dans les limites au départ
int produit;
if (y>(max_value/x)) throw ExceptionDepassement(); // division entiere
else produit=x*y; // pas de dépassement ici
Comme j'ai redéfini des classes pour les différents types fondamentaux,
est-il légitime d'envisager d'introduire ces tests de dépassement dans les
opérateurs redéfinis (reste ensuite le pb de la vitesse d'exécution...) ?
Je ne pense pas qu'il existe une réponse positive à votre problème. Ou
alors dans des bibliothèques non standards ou dans les spécifics de
l'implémentation.
Je ne le crois pas d'abord parce que les quelques sources que je
connais sur des classes grands entiers utilisent l'assembleur. De
plus, il semble que ce bout de littérature C# fournisse une réponse:
http://www.thecodeproject.com/csharp/overflow_checking.asp
Si vous savez disposer d'un type entier faisant 2*siezof(int), vous
pourriez peut-être envisager une autre approche: multiplier dans ce
type et tester la partie haute du résultat. Ça ouvre d'autres
perspectives, que vous pouvez ou non exploiter (une addition dépasse
de 1 ou ne dépasse pas, ce qui n'est pas le cas de la multiplication).
Remarque: les processeurs Intel family (et pourquoi pas d'autres)
mènent la multiplication entière de cette façon. Il est donc permis
d'espérer qu'un compilateur pas trop tarte optimise intelligemment et
que ce soit aussi bon, voire meilleur, que le test préalable.
--
Pierre
Je m'explique : y-a-t-il un moyen que tout le monde connait sauf moi de savoir si une opération sur des entiers (par exemple) va provoquer un "dépassement" de valeur limite , ou doit-on le tester avant chaque opération, comme ceci par exemple, pour une multiplication ?
int max_value=std::numeric_limits<int>().max(); int x=...,y=...; // valeurs dans les limites au départ int produit; if (y>(max_value/x)) throw ExceptionDepassement(); // division entiere else produit=x*y; // pas de dépassement ici Comme j'ai redéfini des classes pour les différents types fondamentaux, est-il légitime d'envisager d'introduire ces tests de dépassement dans les opérateurs redéfinis (reste ensuite le pb de la vitesse d'exécution...) ? Je ne pense pas qu'il existe une réponse positive à votre problème. Ou
alors dans des bibliothèques non standards ou dans les spécifics de l'implémentation.
Je ne le crois pas d'abord parce que les quelques sources que je connais sur des classes grands entiers utilisent l'assembleur. De plus, il semble que ce bout de littérature C# fournisse une réponse: http://www.thecodeproject.com/csharp/overflow_checking.asp
Si vous savez disposer d'un type entier faisant 2*siezof(int), vous pourriez peut-être envisager une autre approche: multiplier dans ce type et tester la partie haute du résultat. Ça ouvre d'autres perspectives, que vous pouvez ou non exploiter (une addition dépasse de 1 ou ne dépasse pas, ce qui n'est pas le cas de la multiplication). Remarque: les processeurs Intel family (et pourquoi pas d'autres) mènent la multiplication entière de cette façon. Il est donc permis d'espérer qu'un compilateur pas trop tarte optimise intelligemment et que ce soit aussi bon, voire meilleur, que le test préalable. -- Pierre
Marc Boyer
Marc wrote:
Je m'explique : y-a-t-il un moyen que tout le monde connait sauf moi de savoir si une opération sur des entiers (par exemple) va provoquer un "dépassement" de valeur limite , ou doit-on le tester avant chaque opération, comme ceci par exemple, pour une multiplication ?
int max_value=std::numeric_limits<int>().max(); int x=...,y=...; // valeurs dans les limites au départ int produit; if (y>(max_value/x)) throw ExceptionDepassement(); // division entiere else produit=x*y; // pas de dépassement ici
C'est la seule métode que je connaisse (à part de convaincre le vendeur du compilateur de le faire lui même).
Comme j'ai redéfini des classes pour les différents types fondamentaux, est-il légitime d'envisager d'introduire ces tests de dépassement dans les opérateurs redéfinis (reste ensuite le pb de la vitesse d'exécution...) ?
Voui. Si tu es intéressé, j'ai fait une classe CheckedNumeric<T> qui fait cela. Elle est accessible depuis: http://www.enseeiht.fr/~boyer/Tools.html
Si tu envisages de l'utiliser et non de t'en inspirer, prévient moi, il y a peut-être 2-3 paufinages à faire.
Marc Boyer -- Je ne respecte plus le code de la route à vélo depuis une double fracture due au fait que j'étais le seul à le respecter.
Marc wrote:
Je m'explique : y-a-t-il un moyen que tout le monde connait sauf moi de
savoir si une opération sur des entiers (par exemple) va provoquer un
"dépassement" de valeur limite , ou doit-on le tester avant chaque
opération, comme ceci par exemple, pour une multiplication ?
int max_value=std::numeric_limits<int>().max();
int x=...,y=...; // valeurs dans les limites au départ
int produit;
if (y>(max_value/x)) throw ExceptionDepassement(); // division entiere
else produit=x*y; // pas de dépassement ici
C'est la seule métode que je connaisse (à part de convaincre
le vendeur du compilateur de le faire lui même).
Comme j'ai redéfini des classes pour les différents types fondamentaux,
est-il légitime d'envisager d'introduire ces tests de dépassement dans les
opérateurs redéfinis (reste ensuite le pb de la vitesse d'exécution...) ?
Voui.
Si tu es intéressé, j'ai fait une classe CheckedNumeric<T> qui
fait cela.
Elle est accessible depuis:
http://www.enseeiht.fr/~boyer/Tools.html
Si tu envisages de l'utiliser et non de t'en inspirer, prévient
moi, il y a peut-être 2-3 paufinages à faire.
Marc Boyer
--
Je ne respecte plus le code de la route à vélo depuis une double fracture
due au fait que j'étais le seul à le respecter.
Je m'explique : y-a-t-il un moyen que tout le monde connait sauf moi de savoir si une opération sur des entiers (par exemple) va provoquer un "dépassement" de valeur limite , ou doit-on le tester avant chaque opération, comme ceci par exemple, pour une multiplication ?
int max_value=std::numeric_limits<int>().max(); int x=...,y=...; // valeurs dans les limites au départ int produit; if (y>(max_value/x)) throw ExceptionDepassement(); // division entiere else produit=x*y; // pas de dépassement ici
C'est la seule métode que je connaisse (à part de convaincre le vendeur du compilateur de le faire lui même).
Comme j'ai redéfini des classes pour les différents types fondamentaux, est-il légitime d'envisager d'introduire ces tests de dépassement dans les opérateurs redéfinis (reste ensuite le pb de la vitesse d'exécution...) ?
Voui. Si tu es intéressé, j'ai fait une classe CheckedNumeric<T> qui fait cela. Elle est accessible depuis: http://www.enseeiht.fr/~boyer/Tools.html
Si tu envisages de l'utiliser et non de t'en inspirer, prévient moi, il y a peut-être 2-3 paufinages à faire.
Marc Boyer -- Je ne respecte plus le code de la route à vélo depuis une double fracture due au fait que j'étais le seul à le respecter.
Marc
Merci à toi j'ai jeté un coup d'oeil sur tes sources. C'est instructif mais je vais pas les utiliser comme ça car je vais plutôt intégrer ces contrôles à des classes existantes, qui implémentent la notion de valeur manquante. Si tu es intéressé, je pourrai te les envoyer, au moins pour avis...(mais pas tout de suite car là je vais être sur autre chose). Marc
Merci à toi
j'ai jeté un coup d'oeil sur tes sources.
C'est instructif mais je vais pas les utiliser comme ça car je vais plutôt
intégrer ces contrôles à des classes existantes, qui implémentent la notion
de valeur manquante.
Si tu es intéressé, je pourrai te les envoyer, au moins pour avis...(mais
pas tout de suite car là je vais être sur autre chose).
Marc
Merci à toi j'ai jeté un coup d'oeil sur tes sources. C'est instructif mais je vais pas les utiliser comme ça car je vais plutôt intégrer ces contrôles à des classes existantes, qui implémentent la notion de valeur manquante. Si tu es intéressé, je pourrai te les envoyer, au moins pour avis...(mais pas tout de suite car là je vais être sur autre chose). Marc
Andre Heinen
On Sat, 6 Nov 2004 11:04:28 +0100, "Marc" wrote:
Je m'explique : y-a-t-il un moyen que tout le monde connait sauf moi de savoir si une opération sur des entiers (par exemple) va provoquer un "dépassement" de valeur limite , ou doit-on le tester avant chaque opération, comme ceci par exemple, pour une multiplication ?
Je crois que la meilleure solution est de commencer par effectuer l'opération, et ensuite de tester les flags du processeur pour vérifier si un problème a eu lieu. Mais évidemment, ce n'est pas portable. De plus, toutes les opérations ne peuvent pas être testées après coup. Une division par zéro, par exemple, arrêtera probablement ton programme avant qu'il n'arrive au test.
Vois aussi la documentation de ton compilateur. Par exemple, en virgule flottante, gcc utilise deux valeurs spéciales, NaN et Inf, pour signaler les erreurs et les overflows.
-- Andre Heinen My address, rot13-encoded: n qbg urvara ng rhebcrnayvax qbg pbz
On Sat, 6 Nov 2004 11:04:28 +0100, "Marc" <metrica@free.fr>
wrote:
Je m'explique : y-a-t-il un moyen que tout le monde connait sauf moi de
savoir si une opération sur des entiers (par exemple) va provoquer un
"dépassement" de valeur limite , ou doit-on le tester avant chaque
opération, comme ceci par exemple, pour une multiplication ?
Je crois que la meilleure solution est de commencer par effectuer
l'opération, et ensuite de tester les flags du processeur pour
vérifier si un problème a eu lieu. Mais évidemment, ce n'est pas
portable. De plus, toutes les opérations ne peuvent pas être
testées après coup. Une division par zéro, par exemple, arrêtera
probablement ton programme avant qu'il n'arrive au test.
Vois aussi la documentation de ton compilateur. Par exemple, en
virgule flottante, gcc utilise deux valeurs spéciales, NaN et
Inf, pour signaler les erreurs et les overflows.
--
Andre Heinen
My address, rot13-encoded: n qbg urvara ng rhebcrnayvax qbg pbz
Je m'explique : y-a-t-il un moyen que tout le monde connait sauf moi de savoir si une opération sur des entiers (par exemple) va provoquer un "dépassement" de valeur limite , ou doit-on le tester avant chaque opération, comme ceci par exemple, pour une multiplication ?
Je crois que la meilleure solution est de commencer par effectuer l'opération, et ensuite de tester les flags du processeur pour vérifier si un problème a eu lieu. Mais évidemment, ce n'est pas portable. De plus, toutes les opérations ne peuvent pas être testées après coup. Une division par zéro, par exemple, arrêtera probablement ton programme avant qu'il n'arrive au test.
Vois aussi la documentation de ton compilateur. Par exemple, en virgule flottante, gcc utilise deux valeurs spéciales, NaN et Inf, pour signaler les erreurs et les overflows.
-- Andre Heinen My address, rot13-encoded: n qbg urvara ng rhebcrnayvax qbg pbz
Marc Boyer
Marc wrote:
Merci à toi j'ai jeté un coup d'oeil sur tes sources. C'est instructif mais je vais pas les utiliser comme ça car je vais plutôt intégrer ces contrôles à des classes existantes, qui implémentent la notion de valeur manquante.
Oui, avec les valeurs manquantes, on doit d'abbord faire le test de valeur manquante puis de débordement, et mes classes ne sont pas adaptées alors.
Si tu es intéressé, je pourrai te les envoyer, au moins pour avis...(mais pas tout de suite car là je vais être sur autre chose).
On a le temps ;-)
Marc Boyer -- Je ne respecte plus le code de la route à vélo depuis une double fracture due au fait que j'étais le seul à le respecter.
Marc wrote:
Merci à toi
j'ai jeté un coup d'oeil sur tes sources.
C'est instructif mais je vais pas les utiliser comme ça car je vais plutôt
intégrer ces contrôles à des classes existantes, qui implémentent la notion
de valeur manquante.
Oui, avec les valeurs manquantes, on doit d'abbord faire le test
de valeur manquante puis de débordement, et mes classes ne
sont pas adaptées alors.
Si tu es intéressé, je pourrai te les envoyer, au moins pour avis...(mais
pas tout de suite car là je vais être sur autre chose).
On a le temps ;-)
Marc Boyer
--
Je ne respecte plus le code de la route à vélo depuis une double fracture
due au fait que j'étais le seul à le respecter.
Merci à toi j'ai jeté un coup d'oeil sur tes sources. C'est instructif mais je vais pas les utiliser comme ça car je vais plutôt intégrer ces contrôles à des classes existantes, qui implémentent la notion de valeur manquante.
Oui, avec les valeurs manquantes, on doit d'abbord faire le test de valeur manquante puis de débordement, et mes classes ne sont pas adaptées alors.
Si tu es intéressé, je pourrai te les envoyer, au moins pour avis...(mais pas tout de suite car là je vais être sur autre chose).
On a le temps ;-)
Marc Boyer -- Je ne respecte plus le code de la route à vélo depuis une double fracture due au fait que j'étais le seul à le respecter.
Alain Naigeon
"Marc Boyer" a écrit dans le message news: cmpuio$1he$
Je ne respecte plus le code de la route à vélo depuis une double fracture due au fait que j'étais le seul à le respecter.
Tu veux dire le seul vélo ?
--
Français *==> "Musique renaissance" <==* English midi - facsimiles - ligatures - mensuration http://anaigeon.free.fr | http://www.medieval.org/emfaq/anaigeon/ Alain Naigeon - - Strasbourg, France
"Marc Boyer" <Marc.Boyer@enseeiht.yahoo.fr.invalid> a écrit dans le message
news: cmpuio$1he$1@news.cict.fr...
Je ne respecte plus le code de la route à vélo depuis une double fracture
due au fait que j'étais le seul à le respecter.
Tu veux dire le seul vélo ?
--
Français *==> "Musique renaissance" <==* English
midi - facsimiles - ligatures - mensuration
http://anaigeon.free.fr | http://www.medieval.org/emfaq/anaigeon/
Alain Naigeon - anaigeon@free.fr - Strasbourg, France
