Come convertire un float in un int in C++

Per convertire un float C++ in un int e scartarne la parte frazionaria, usa static_cast<int>(value). Una conversione da virgola mobile a intero tronca verso zero: 4.8f diventa 4, mentre -4.8f diventa -4. Se ti serve una regola di arrotondamento diversa, scegli una funzione da <cmath> prima di convertire.

Usare l’assegnazione diretta per convertire un float in un int

L’assegnazione diretta converte implicitamente un float in un int. La parte frazionaria viene scartata. Ecco un programma compatto che assegna un valore familiare e mostra l’intero convertito:

#include <iostream>

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

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

La semantica di conversione del C++ dà il valore intero 4 per 4.8f. L’esempio stampa:

4

Per gli input negativi, il troncamento si muove comunque verso zero, quindi -4.8f si converte in -4 anziché nel valore floor -5.

Usare un cast in stile C per convertire un float in un int

Un cast in stile C scrive il tipo di destinazione tra parentesi, come in int result = (int)value;. Per un valore scalare in virgola mobile, produce lo stesso risultato di troncamento verso zero dell’assegnazione diretta e di static_cast<int>(value), a condizione che il valore convertito sia rappresentabile come int.

I cast in stile C possono esprimere diversi tipi di conversioni, quindi il loro effetto è meno esplicito a colpo d’occhio. Nel C++ moderno, preferisci static_cast<int>(value) quando questa è la conversione che intendi. La notazione in stile C rimane utile da riconoscere nel codice esistente, ma non cambia il modo in cui un valore in virgola mobile viene troncato.

Usare static_cast per convertire un float in un int

Usa static_cast<int>(value) per rendere esplicita la conversione e identificarne il tipo di destinazione. Per un valore in virgola mobile, static_cast tronca verso zero; non arrotonda all’intero più vicino né verifica se il risultato rientra in un int.

La conversione ha un comportamento indefinito se il valore troncato non può essere rappresentato da int. Verificare che il valore originale rientri nei limiti di int prima di convertire è una protezione prudente: può rifiutare alcuni valori frazionari il cui risultato troncato rientrerebbe comunque. static_cast non limita né convalida il valore. Vedi il riferimento di static_cast per le regole del linguaggio e le altre conversioni supportate dall’operatore.

Usare strategie di arrotondamento per convertire un float in un int

Scegli una funzione di arrotondamento quando il troncamento verso zero non è il risultato desiderato. Includi <cmath> e applica la funzione prima di convertire il suo risultato in int. Anche il valore arrotondato deve essere rappresentabile come int.

Arrotondamento per difetto (Floor)

std::floor(value) restituisce il più grande valore integrale minore o uguale all’input. Ad esempio, floor dà 4 per 4.8f e -5 per -4.8f. Questo differisce dalla conversione diretta in int, che dà rispettivamente 4 e -4. Per memorizzare un risultato di floor come intero, usa static_cast<int>(std::floor(value)) dopo esserti assicurato che rientri nell’intervallo.

Arrotondamento per eccesso (Ceil)

std::ceil(value) restituisce il più piccolo valore integrale maggiore o uguale all’input. Dà 5 per 4.8f e -4 per -4.8f. Converti quel risultato con static_cast<int>(std::ceil(value)) quando serve un intero e il risultato rientra in un int.

Arrotondamento all’intero più vicino

std::round(value) seleziona il valore integrale più vicino, con i casi a metà strada arrotondati allontanandosi da zero. Così std::round(4.5f) è 5, e std::round(-4.5f) è -5. Usa static_cast<int>(std::round(value)) per ottenere un intero, verificando di nuovo che il risultato arrotondato sia rappresentabile. Questa regola differisce dal troncamento, da floor e da ceil, soprattutto per gli input negativi.

Conclusione

Per la normale conversione da float a int, static_cast<int>(value) rende chiara l’intenzione e tronca verso zero. L’assegnazione diretta e un cast in stile C hanno lo stesso comportamento di troncamento per valori adeguati, ma il cast con nome è più facile da riconoscere come una conversione C++ deliberata. Usa std::floor, std::ceil o std::round da <cmath> quando le rispettive regole di arrotondamento corrispondono all’attività. Prima di qualsiasi conversione, assicurati che il valore prodotto dal troncamento o dall’arrotondamento rientri nell’intervallo di int; nessuno di questi cast lo verifica o lo regola per te.