`std::is_integral` în C++

Tipuri: traits, concepte, întregi cu mărime fixă C++11

is_integral verifică dacă un tip este întreg (inclusiv bool și char); is_floating_point, dacă este real.

Sintaxă

#include <type_traits>
std::is_integral_v<T>
std::is_floating_point_v<T>

Ce face `std::is_integral`

std::is_integral_v<T> este true pentru tipurile întregi: int, long, unsigned, short, dar și bool, char, char8_t. std::is_floating_point_v<T> este true pentru float, double, long double.

Ambele ignoră const/volatile, dar nu și referințele: int& nu este considerat întreg. Sunt folosite în static_assert, if constexpr și std::enable_if; în C++20 conceptele std::integral și std::floating_point fac același lucru mai lizibil.

Parametri

Parametru	Descriere
`T`	Tipul verificat.

Ce returnează

O constantă bool la compilare.

Exemple

Exemplul 1: Ce tipuri sunt întregi și ce tipuri sunt reale

#include <print>
#include <string>
#include <type_traits>

int main() {
    std::println("{:12} {:9} {}", "tip", "întreg", "real");
    std::println("{:12} {:9} {}", "int", std::is_integral_v<int>, std::is_floating_point_v<int>);
    std::println("{:12} {:9} {}", "bool", std::is_integral_v<bool>, std::is_floating_point_v<bool>);
    std::println("{:12} {:9} {}", "char", std::is_integral_v<char>, std::is_floating_point_v<char>);
    std::println("{:12} {:9} {}", "const long", std::is_integral_v<const long>, std::is_floating_point_v<const long>);
    std::println("{:12} {:9} {}", "double", std::is_integral_v<double>, std::is_floating_point_v<double>);
    std::println("{:12} {:9} {}", "int&", std::is_integral_v<int&>, std::is_floating_point_v<int&>);
    std::println("{:12} {:9} {}", "std::string", std::is_integral_v<std::string>, std::is_floating_point_v<std::string>);
}

Rezultat

tip          întreg    real
int          true      false
bool         true      false
char         true      false
const long   true      false
double       false     true
int&         false     false
std::string  false     false

Exemplul 2: Formatare diferită după tip

#include <print>
#include <type_traits>

template <class T>
void pret(T valoare) {
    static_assert(std::is_integral_v<T> || std::is_floating_point_v<T>, "prețul trebuie să fie un număr");
    if constexpr (std::is_floating_point_v<T>) {
        std::println("{:.2f} lei", valoare);
    } else {
        std::println("{} lei", valoare);
    }
}

int main() {
    pret(25);
    pret(19.9);
}