Arrondir un entier le plus proche possible de sa dizaine..?

Bonjour / Bonsoir à tous ! ;)

Alors voilà, j'aimerais que vous m'expliquiez comment je pourrais faire pour arrondir un nombre / chiffre ENTIER de sa dizaine la plus proche ?

Exemple :

Si je mets ma variable NUMBER à 4, que le programme m'affiche 0 ( car 4 est plus proche de 0 que de 10 ) et inversement, si je mets ma variable NUMBER à 6 ( par exemple ), que le programme m'affiche 10..

Et ce, pour TOUTES les dizaines entre 0 et 100, donc si je mets ma variable NUMBER à 87, je veux que le résultat 90 s'affiche.
Bref, je pense avoir été clair :-)

Merci à vous pour l'aide car je n'ai trouvé sur google que des explications pour des chiffres à virgules... ! :-)

Diviser par 10.0f pour obtenir un float, std::round pour arrondir, multiplier par 10 et enfin récupérer un entier ?

Bonsoir,
Je propose sa:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

#include <cmath>   long arrondir( long nombre/* Nombre a arrondir */, unsigned k/* 1 pour dizaine, 2 pour ...*/) { if( k > 0) { int signe = 1; if( nombre < 0) { nombre = -nombre; signe = -1; } unsigned long p = std::pow( 10, k); /* Arrondir a droite */ if( ( nombre % p) >= p/2) { return signe * ( ( nombre/p)*p + p); } /* Arrondir a gauche */ return signe * ( nombre / p)*p; } return nombre; }

---

C'est un peu plus compliquer que ce que t'attendais, mais si elle s’exécute comme je le veut bien, tu pourras arrondir au-dela de la dizaine, enfin j'espère.
En plus elle devrait supporter les entiers négatif enfin j'espère ;)

Si quelqu'un a une proposition d’amélioration ou un autre code je suis prenant bien sur.

@Ratator :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

#include <iostream> #include <cassert>   int arrondir(int entier, int precision) { assert(precision > 0); const int offset = (entier >= 0) ? precision/2 : -precision/2; return ( (entier+offset) / precision ) * precision; }   int main() { std::cout << "arrondir(-36, 10) : " << arrondir(-36, 10) << '\n' << "arrondir(-25, 10) : " << arrondir(-25, 10) << '\n' << "arrondir(-14, 10) : " << arrondir(-14, 10) << '\n' << "arrondir(104, 10) : " << arrondir(104, 10) << '\n' << "arrondir(225, 10) : " << arrondir(225, 10) << '\n' << "arrondir(346, 10) : " << arrondir(346, 10) << '\n' << "arrondir(2547, 100) : " << arrondir(2547, 100) << '\n' << "arrondir(121, 25) : " << arrondir(121, 25) << '\n' << "arrondir(-18, 5) : " << arrondir(-18, 5) << '\n' << "arrondir(-17, 5) : " << arrondir(-17, 5); return 0; }

---

Sortie :

Code:

---

1 2 3 4 5 6 7 8 9 10

arrondir(-36, 10) : -40 arrondir(-25, 10) : -30 arrondir(-14, 10) : -10 arrondir(104, 10) : 100 arrondir(225, 10) : 230 arrondir(346, 10) : 350 arrondir(2547, 100) : 2500 arrondir(121, 25) : 125 arrondir(-18, 5) : -20 arrondir(-17, 5) : -15

---

Merci pour le poste, sa m'as pas permis de me renseigner un peu sur <cassert>.
Mais il y-a quelques choses que je ne comprends pas

Code:

---

assert(precision > 0);

---

pourquoi l'avez-vous utiliser?
Sa me dépasse, puisque lorsque precision est <= 0 sa arrête le programme.

Citation:

---

Envoyé par Ratator

Code:

---

assert(precision > 0);

---

pourquoi l'avez-vous utiliser?
Sa me dépasse, puisque lorsque precision est <= 0 sa arrête le programme.

---

La macro assert ne peut avoir d'effet que si la macro NDEBUG n'est pas définie. On utilise assert pour détecter les erreurs de programmation.
Dans cet exemple, j'impose à l'appelant que precision > 0. S'il a un entier precision qui peut être négatif, alors il est obligé de faire un contrôle explicite, par exemple :

Code:

---

1 2 3 4 5 6 7

if(precision > 0) { resultat = arrondir(entier, precision); } else { // Afficher un message qui demande à l'utilisateur de // choisir une précision strictement positive. }

---

S'il oublie de le faire, alors c'est détecté comme étant une erreur de programmation.

En général, on compile le programme dans deux modes différents :

• Le mode Debug qui permet d'analyser facilement les bogues au moment où le programme est développé. Il permet d'exécuter le programme ligne par ligne. La macro NDEBUG n'est pas définie. Quand une erreur de programmation est trouvée par assert, le programme s'arrête tout de suite et le développeur peut visualiser l'état du programme. Si on n'avait pas arrêté le programme, le programme aurait dysfonctionné plus tard, à un endroit plus éloigné de l'origine de l'erreur. Analyser l'erreur aurait alors été plus long.
• Le mode Release qui est le mode utilisé pour déployer le logiciel. Le compilateur peut faire des optimisations agressives en changeant les instructions et leur ordre. La macro NDEBUG est définie pour désactiver les assert.

En mode Release, il y a plusieurs manières de gérer les erreurs de programmation.

1. Ne pas les gérer. C'est ce que j'ai fait :
   
   Code:

   ---

   1 2 3 4 5 6

   int arrondir(int entier, int precision) { assert(precision > 0); const int offset = (entier >= 0) ? precision/2 : -precision/2; return ( (entier+offset) / precision ) * precision; }

   ---

   Quand NDEBUG est définie, mon code se comporte n'importe comment si precision <= 0. L'appelant n'avait qu'à faire attention.
2. Les réparer sur place.
   
   Code:

   ---

   1 2 3 4 5 6 7 8 9 10

   int arrondir(int entier, int precision) { assert(precision > 0); if(precision > 0) { const int offset = (entier >= 0) ? precision/2 : -precision/2; return ( (entier+offset) / precision ) * precision; } else { return entier; } }

   ---

   C'est un tout petit peu moins performant, car on a un if en plus, mais c'est plus sécurisé. L'inconvénient est que cela a tendance à cacher partiellement l'erreur de programmation. Donc elle risque de traîner dans le programme plus longtemps.
3. Lever une exception.
   
   Code:

   ---

   1 2 3 4 5 6 7 8 9 10

   #include <stdexcept>   int arrondir(int entier, int precision) { assert(precision > 0); if(precision <= 0) throw std::domain_error("arrondir : la precision (" + std::to_string(precision) + ") aurait du etre > 0."); const int offset = (entier >= 0) ? precision/2 : -precision/2; return ( (entier+offset) / precision ) * precision; }

   ---

   C'est ma préférée. Mais peut-être que FrostfallDelphi et vous n'avez pas encore vu les exceptions.

Citation:

---

Quand NDEBUG est définie, mon code se comporte n'importe comment si precision <= 0. L'appelant n'avait qu'à faire attention.

---

Bien fait pour lui :mouarf:.

Citation:

---

Mais peut-être que FrostfallDelphi et vous n'avez pas encore vu les exceptions.

---

Effectivement je n'ai vu que comment gérer les exceptions avec

Code:

---

try catch()

---

, mais j'ai pas encore vue comment générer des exceptions, je n'en voyais pas l'utilité, c'est plus le cas maintenant grâce à vous.
Vous connaissez un cours/tutoriel assez bien fait sur la gestion des erreurs?

Citation:

---

Envoyé par Ratator

Vous connaissez un cours/tutoriel assez bien fait sur la gestion des erreurs?

---

Dans l'ensemble, je trouve la page suivante plutôt bien faite :
https://isocpp.org/wiki/faq/exceptions

Technique du round des flottants appliqué aux entiers : +5 / 10 : int arrondiDizaine(int i) { return (i+5) / 10; }
Plutôt qu'un assert, pourquoi ne pas avoir precision en unsigned int ? :calim2:

J'aurais préféré que se soit en Français.

J'ai l'impression que plus j'apprends/découvre des nouvelles choses et plus il me reste des choses a découvrir, plus qu'avant.

C'est juste moi ou est ce le cas pour tout le monde?

C'est tout le monde normalement. Ceux qui disent le contraire sont des menteurs. Il y a d'ailleurs une citation plutôt célèbre à ce sujet.

Citation:

---

Envoyé par Bousk

Plutôt qu'un assert, pourquoi ne pas avoir precision en unsigned int ? :calim2:

---

Avec un unsigned, il faudrait quand même un assert pour exclure le cas precision == 0.
J'ai hésité à mettre un unsigned. Mais, de toutes façons, il aurait fallu convertir en int :

Code:

---

1 2 3 4 5 6 7 8 9

int arrondir(int entier, unsigned precision) { assert(precision > 0); if(precision == 0) throw std::domain_error("arrondir : la precision (" + std::to_string(precision) + "aurait du etre > 0."); const int intPrecision = static_cast<int>(precision); const int offset = (entier >= 0) ? intPrecision/2 : -intPrecision/2; return ( (entier+offset) / intPrecision ) * intPrecision; }

---

Sans la conversion en int, (entier+offset) / precision aurait été non signé et le résultat aurait été erroné.
Du coup, j'ai préféré le type int.