Cómo convertir un float en un int en C++

Para convertir un float de C++ en un int y descartar su parte fraccionaria, usa static_cast<int>(value). Una conversión de punto flotante a entero trunca hacia cero: 4.8f se convierte en 4, mientras que -4.8f se convierte en -4. Si necesitas una regla de redondeo diferente, elige una función de <cmath> antes de convertir.

Usar la asignación directa para convertir un float en un int

La asignación directa convierte un float en un int implícitamente. La parte fraccionaria se descarta. Aquí tienes un programa compacto que asigna un valor familiar y muestra el entero convertido:

#include <iostream>

int main() {
    float value = 4.8f;
    int result = value;

    std::cout << result << '\n';
}

La semántica de conversión de C++ da el valor entero 4 para 4.8f. El ejemplo imprime:

4

Para entradas negativas, la truncación sigue moviéndose hacia cero, por lo que -4.8f se convierte en -4 en lugar del valor suelo -5.

Usar una conversión al estilo C para convertir un float en un int

Una conversión al estilo C escribe el tipo de destino entre paréntesis, como en int result = (int)value;. Para un valor escalar de punto flotante, produce el mismo resultado de truncación hacia cero que la asignación directa y static_cast<int>(value), siempre que el valor convertido sea representable como un int.

Las conversiones al estilo C pueden expresar varios tipos de conversiones, por lo que su efecto es menos explícito a simple vista. En C++ moderno, prefiere static_cast<int>(value) cuando esta es la conversión que pretendes. La notación al estilo C sigue siendo útil para reconocerla en código existente, pero no cambia cómo se trunca un valor de punto flotante.

Usar static_cast para convertir un float en un int

Usa static_cast<int>(value) para hacer la conversión explícita e identificar su tipo de destino. Para un valor de punto flotante, static_cast trunca hacia cero; no redondea al entero más cercano ni comprueba si el resultado cabe en un int.

La conversión tiene un comportamiento indefinido si el valor truncado no puede ser representado por int. Comprobar que el valor original está dentro de los límites de int antes de convertir es una protección conservadora: puede rechazar algunos valores fraccionarios cuyo resultado truncado aún cabría. static_cast no limita ni valida el valor. Consulta la referencia de static_cast para conocer las reglas del lenguaje y otras conversiones admitidas por el operador.

Usar estrategias de redondeo para convertir un float en un int

Elige una función de redondeo cuando la truncación hacia cero no es el resultado deseado. Incluye <cmath> y aplica la función antes de convertir su resultado a int. El valor redondeado también debe ser representable como un int.

Redondeo hacia abajo (Floor)

std::floor(value) devuelve el mayor valor integral menor o igual que la entrada. Por ejemplo, floor da 4 para 4.8f y -5 para -4.8f. Esto difiere de convertir directamente a int, que da 4 y -4 respectivamente. Para almacenar un resultado de floor como entero, usa static_cast<int>(std::floor(value)) después de asegurarte de que está dentro del rango.

Redondeo hacia arriba (Ceil)

std::ceil(value) devuelve el menor valor integral mayor o igual que la entrada. Da 5 para 4.8f y -4 para -4.8f. Convierte ese resultado con static_cast<int>(std::ceil(value)) cuando se necesita un entero y el resultado cabe en un int.

Redondeo al entero más cercano

std::round(value) selecciona el valor integral más cercano, con los casos a mitad de camino redondeados alejándose de cero. Así, std::round(4.5f) es 5, y std::round(-4.5f) es -5. Usa static_cast<int>(std::round(value)) para obtener un entero, comprobando de nuevo que el resultado redondeado es representable. Esta regla difiere de la truncación, floor y ceil, especialmente para entradas negativas.

Conclusión

Para la conversión ordinaria de float a int, static_cast<int>(value) deja clara la intención y trunca hacia cero. La asignación directa y una conversión al estilo C tienen el mismo comportamiento de truncación para valores adecuados, pero la conversión con nombre es más fácil de reconocer como una conversión deliberada de C++. Usa std::floor, std::ceil o std::round de <cmath> cuando sus respectivas reglas de redondeo se ajusten a la tarea. Antes de cualquier conversión, asegúrate de que el valor producido por la truncación o el redondeo cabe en el rango de int; ninguna de estas conversiones lo comprueba ni lo ajusta por ti.