Comment convertir un float en int en C++

Pour convertir un float C++ en int et écarter sa partie fractionnaire, utilisez static_cast<int>(value). Une conversion de flottant vers entier tronque vers zéro : 4.8f devient 4, tandis que -4.8f devient -4. Si vous avez besoin d’une règle d’arrondi différente, choisissez une fonction de <cmath> avant de convertir.

Utiliser l’affectation directe pour convertir un float en int

L’affectation directe convertit implicitement un float en int. La partie fractionnaire est écartée. Voici un programme compact qui affecte une valeur familière et affiche l’entier converti :

#include <iostream>

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

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

La sémantique de conversion du C++ donne la valeur entière 4 pour 4.8f. L’exemple affiche :

4

Pour les entrées négatives, la troncature se déplace toujours vers zéro, donc -4.8f se convertit en -4 plutôt qu’en la valeur plancher -5.

Utiliser un cast de style C pour convertir un float en int

Un cast de style C écrit le type cible entre parenthèses, comme dans int result = (int)value;. Pour une valeur flottante scalaire, il produit le même résultat de troncature vers zéro que l’affectation directe et static_cast<int>(value), à condition que la valeur convertie soit représentable comme un int.

Les casts de style C peuvent exprimer plusieurs types de conversions, de sorte que leur effet est moins explicite au premier coup d’œil. En C++ moderne, préférez static_cast<int>(value) lorsque c’est la conversion que vous visez. L’écriture de style C reste utile à reconnaître dans le code existant, mais elle ne change pas la façon dont une valeur flottante est tronquée.

Utiliser static_cast pour convertir un float en int

Utilisez static_cast<int>(value) pour rendre la conversion explicite et identifier son type de destination. Pour une valeur flottante, static_cast tronque vers zéro ; il n’arrondit pas à l’entier le plus proche et ne vérifie pas si le résultat tient dans un int.

La conversion a un comportement indéfini si la valeur tronquée ne peut pas être représentée par int. Vérifier que la valeur d’origine se situe dans les limites de int avant de convertir est une protection prudente : elle peut rejeter certaines valeurs fractionnaires dont le résultat tronqué tiendrait encore. static_cast ne limite ni ne valide la valeur. Voir la référence de static_cast pour les règles du langage et les autres conversions prises en charge par l’opérateur.

Utiliser des stratégies d’arrondi pour convertir un float en int

Choisissez une fonction d’arrondi lorsque la troncature vers zéro n’est pas le résultat souhaité. Incluez <cmath> et appliquez la fonction avant de convertir son résultat en int. La valeur arrondie doit également être représentable comme un int.

Arrondi vers le bas (Floor)

std::floor(value) renvoie la plus grande valeur entière inférieure ou égale à l’entrée. Par exemple, floor donne 4 pour 4.8f et -5 pour -4.8f. Cela diffère de la conversion directe en int, qui donne respectivement 4 et -4. Pour stocker un résultat de floor comme entier, utilisez static_cast<int>(std::floor(value)) après vous être assuré qu’il est dans la plage.

Arrondi vers le haut (Ceil)

std::ceil(value) renvoie la plus petite valeur entière supérieure ou égale à l’entrée. Elle donne 5 pour 4.8f et -4 pour -4.8f. Convertissez ce résultat avec static_cast<int>(std::ceil(value)) lorsqu’un entier est nécessaire et que le résultat tient dans un int.

Arrondi à l’entier le plus proche

std::round(value) sélectionne la valeur entière la plus proche, les cas à mi-chemin étant arrondis en s’éloignant de zéro. Ainsi, std::round(4.5f) vaut 5, et std::round(-4.5f) vaut -5. Utilisez static_cast<int>(std::round(value)) pour obtenir un entier, en vérifiant à nouveau que le résultat arrondi est représentable. Cette règle diffère de la troncature, de floor et de ceil, en particulier pour les entrées négatives.

Conclusion

Pour la conversion ordinaire de float vers int, static_cast<int>(value) rend l’intention claire et tronque vers zéro. L’affectation directe et un cast de style C ont le même comportement de troncature pour des valeurs appropriées, mais le cast nommé est plus facile à reconnaître comme une conversion C++ délibérée. Utilisez std::floor, std::ceil ou std::round de <cmath> lorsque leurs règles d’arrondi respectives correspondent à la tâche. Avant toute conversion, assurez-vous que la valeur produite par la troncature ou l’arrondi tient dans la plage de int ; aucun de ces casts ne la vérifie ni ne l’ajuste pour vous.