conversiones de tipo de punto flotante C++ a entero

Question

¿Cuáles son las diferentes técnicas utilizadas para convertir el tipo de datos flotantes a entero 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

manera normal es:

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

Answer 2

Lo que se busca es 'la conversión de tipos'. Encasillamiento (poniendo el tipo que sabe que quiere entre paréntesis) le dice al compilador que usted sabe lo que está haciendo y está contento con él. La forma antigua heredada de C es la siguiente.

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

única Si tuviera tratado de escribir

int var_b = var_a; 

Usted habría conseguido una advertencia de que no se puede implícitamente (automáticamente) convertir un float a un int, a medida que pierde el decimal.

Esto se conoce como la forma antigua, ya que C++ ofrece una alternativa superior, "transmisió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 aliento, sino que proporciona un mejor manejo de situaciones tales como solicitar accidentalmente un 'vaciado estático' en un tipo que no se puede convertir. Para obtener más información sobre el motivo por el que debería utilizar el envío estático, consulte this question.

Answer 3

Creo que se puede hacer esto mediante un reparto:

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

Answer 4

la técnica más sencilla es simplemente asignar flotador para int, por ejemplo:

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

este truncará todo atrás punto o flotantes puedes redondear tu número flotante antes.

Answer 5

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

#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 6

Salida del impulso NumericConversion biblioteca. Le permitirá controlar explícitamente cómo desea tratar problemas como el manejo de desbordamiento y el truncamiento.

Answer 7

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

int someint = (somedouble+epsilon); 

Answer 8

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

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