C++ virgule flottante pour les conversions de type integer

Quelles sont les différentes techniques utilisées pour convertir flotteur type de données entier en C++?

#include<iostream>
using namespace std;
struct database
{
    int id,age;
    float salary;
};
int main()
{
    struct database employee;
    employee.id=1;
    employee.age=23;
    employee.salary=45678.90; 
    /*
    How can i print this value as an integer
    (with out changing the salary data type in the declaration part) ?
    */
    cout<<endl<<employee.id<<endl<<employee.age<<endl<<employee.salary<<endl;
    return 0;
}

cs.tut.fi/~jkorpela/round.html

InformationsquelleAutor |

c++floating-point integer type-conversion typecast-operator

47

Ce que vous cherchez est "la conversion de type'. typecasting (mettre le type de savoir vous voulez entre parenthèses) indique au compilateur que vous savez ce que vous faites et êtes cool avec elle. Le vieux chemin qui est hérité de C est comme suit.
```
float var_a = 9.99;
int   var_b = (int)var_a;
```
Si vous aviez seulement essayé d'écrire
```
int var_b = var_a;
```
Vous avez reçu un avertissement que vous ne pouvez pas implicitement (automatiquement) de convertir un float à un int, que vous perdez la virgule.

C'est dénommé à l'ancienne comme le C++ offre une alternative supérieure, statique exprimés"; cela fournit une façon beaucoup plus sécuritaire de la conversion d'un type vers un autre. L'équivalent de la méthode (et la façon dont vous devriez le faire)
```
float var_x = 9.99;
int   var_y = static_cast<int>(var_x);
```
Cette méthode peut paraître un peu plus longue haleine, mais il fournit beaucoup mieux à la manipulation de situations telles que accidentellement une demande de "statique cast" sur un type qui ne peut pas être converti. Pour plus d'informations sur le pourquoi devriez-vous utiliser statique de la fonte, voir cette question.
- Je ne comprends pas le bas de vote? soins à donner une raison?
- Je n'ai pas downvote, mais elle peut être due à vous à l'aide de C style jette dans le code C++. Il est mal vu que c'est mauvais style
- Je suis? vraiment? désolé, c'est la façon dont je pensais que j'étais censé faire
- "Bonne" façon statique en fonte. Pragmatique, est-ce. Je vais pragmatique. =)
- wow, parler de l'excavation de la pâte. Je pense que nous pouvons tous convenir que l'acceptation de la technique, TECHNIQUEMENT, C castes sont encore valide en C++ et doivent être couverts... boy que j'ai appris beaucoup de choses depuis que j'ai écrit pour la première fois cette réponse 😛
- À part peut-être NaN, comment pourrais-le au-dessus de "l'ancienne méthode" code de résultat dans un unconvertible type? Nous savons à l'avance que var_a est un float.
- que voulez-vous dire? Si vous avez un flotteur, vous pouvez 'type C' convertir un int, mais c'est une mauvaise pratique à utiliser cette approche, voir la question liée.
InformationsquelleAutor
30

Façon normale est de:
```
float f = 3.4;
int n = static_cast<int>(f);
```
- Des informations supplémentaires sur le résultat serait utile.
InformationsquelleAutor

Taille de certains types float peut dépasser la taille de int.
Cet exemple montre d'un coffre-fort conversion de tout type float pour int à l'aide de la int safeFloatToInt(const FloatType &num); fonction:

#include <iostream>
#include <limits>
using namespace std;

template <class FloatType>
int safeFloatToInt(const FloatType &num) {
   //check if float fits into integer
   if ( numeric_limits<int>::digits < numeric_limits<FloatType>::digits) {
      //check if float is smaller than max int
      if( (num < static_cast<FloatType>( numeric_limits<int>::max())) &&
          (num > static_cast<FloatType>( numeric_limits<int>::min())) ) {
         return static_cast<int>(num); //safe to cast
      } else {
        cerr << "Unsafe conversion of value:" << num << endl;
        //NaN is not defined for int return the largest int value
        return numeric_limits<int>::max();
      }
   } else {
      //It is safe to cast
      return static_cast<int>(num);
   }
}
int main(){
   double a=2251799813685240.0;
   float b=43.0;
   double c=23333.0;
   //unsafe cast
   cout << safeFloatToInt(a) << endl;
   cout << safeFloatToInt(b) << endl;
   cout << safeFloatToInt(c) << endl;
   return 0;
}

Résultat:

Unsafe conversion of value:2.2518e+15
2147483647
43
23333

pas de compilation à tous (cxx11)

InformationsquelleAutor

4

Pour la plupart des cas (long de flotteurs, long long double et long double):
```
long a{ std::lround(1.5f) }; //2l
long long b{ std::llround(std::floor(1.5)) }; //1ll
```
InformationsquelleAutor
3

Découvrez le coup de pouce NumericConversion de la bibliothèque. Elle permettra de contrôler explicitement la façon dont vous souhaitez faire face à des questions comme la gestion de dépassement et de troncature.

InformationsquelleAutor
0

Je crois que vous pouvez le faire à l'aide d'un plâtre:
```
float f_val = 3.6f;
int i_val = (int) f_val;
```
InformationsquelleAutor
0

la technique la plus facile est de simplement attribuer float int, par exemple:
```
int i;
float f;
f = 34.0098;
i = f;
```
ce sera tronquée, tout derrière virgule flottante ou vous pouvez de votre tour de nombre à virgule avant.

InformationsquelleAutor
-1

Une chose que je veux ajouter. Parfois, il peut y avoir perte de précision. Vous pouvez ajouter un peu de valeur epsilon d'abord avant de les convertir. Pas sûr, pourquoi ce qui marche... mais ça marche.
```
int someint = (somedouble+epsilon);
```
InformationsquelleAutor

Vous devez vous connecter pour publier un commentaire.