tipos - itoa c++

Conversiones de tipo flotante a entero de C++

Question

¿Cuáles son las diferentes técnicas utilizadas para convertir los datos de tipo flotante en enteros 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;
}

Answer 1

Creo que puedes hacer esto usando un elenco:

float f_val = 3.6f;
int i_val = (int) f_val;

Answer 2

Echa un vistazo a la biblioteca de impulso NumericConversion . Permitirá controlar de forma explícita cómo desea tratar problemas como el manejo de desbordamiento y el truncamiento.

Answer 3

El tamaño de algunos tipos de flotadores puede exceder el tamaño de int . Este ejemplo muestra una conversión segura de cualquier tipo de int safeFloatToInt(const FloatType &num); flotante a int usando int safeFloatToInt(const FloatType &num); función:

#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;
}

Resultado:

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

Answer 4

La forma normal es:

float f = 3.4;
int n = static_cast<int>(f);

Answer 5

La técnica más sencilla es simplemente asignar float a int, por ejemplo:

int i;
float f;
f = 34.0098;
i = f;

esto truncará todo detrás del punto flotante o puede redondear su número de flotador antes.

Answer 6

Lo que estás buscando es ''tipo casting''. encasillado (poniendo entre corchetes el tipo que usted sabe que quiere) le dice al compilador que sabe lo que está haciendo y le agrada. La forma antigua que se hereda de C es la siguiente.

float var_a = 9.99;
int   var_b = (int)var_a;

Si solo hubieras tratado de escribir

int var_b = var_a;

Habría recibido una advertencia de que no puede (implícitamente) convertir un float a un int , ya que pierde el decimal.

Esto se conoce como la forma antigua, ya que C ++ ofrece una alternativa superior, ''conversión estática''; Esto proporciona una forma mucho más segura de convertir de un tipo a otro. El método equivalente sería (y la forma en que debe hacerlo)

float var_x = 9.99;
int   var_y = static_cast<int>(var_x);

Este método puede parecer un poco más largo, pero proporciona un manejo mucho mejor para situaciones tales como solicitar accidentalmente una ''conversión estática'' en un tipo que no se puede convertir. Para obtener más información sobre el motivo por el que debería usar la conversión estática, consulte esta pregunta .

Answer 7

Para la mayoría de los casos (largo para flotadores, largo para doble y largo doble):

long a{ std::lround(1.5f) }; //2l
long long b{ std::llround(std::floor(1.5)) }; //1ll

Answer 8

Una cosa que quiero agregar. A veces, puede haber pérdida de precisión. Es posible que desee agregar algún valor de épsilon antes de convertir. No estoy seguro de por qué funciona ... pero funciona.

int someint = (somedouble+epsilon);