Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

std::integral — vincolare i tipi interi

std::integral di <concepts> verifica in fase di compilazione se un tipo è intero. Include anche bool e i tipi carattere, mantiene il risultato con i qualificatori const e volatile, ma rifiuta riferimenti, enumerazioni e tipi in virgola mobile.

Versione: C++23; repository compiler flag, production runtime not attested

Sintassi

#include <concepts>

// Definition in namespace std:
template<class T>
concept integral = is_integral_v<T>;

// Usage:
// template<std::integral T> ...
// template<class T> requires std::integral<T> ...

std::integral<T> è un concept di <concepts>, definito come std::is_integral_v<T>. Verifica una categoria di tipo in fase di compilazione, non il valore di un argomento: double non lo soddisfa nemmeno quando contiene 4.0.

Il concept include i tipi interi con e senza segno, oltre a bool e ai tipi carattere come char e wchar_t. I tipi enumerati e le classi non lo soddisfano solo perché possono essere convertiti in int. I qualificatori const e volatile non modificano il risultato: std::integral<const int> è vero. I riferimenti, invece, non sono tipi interi, quindi std::integral<int&> è falso.

Usa template<std::integral T> per vincolare l’argomento di tipo T; in alternativa, puoi scrivere template<class T> requires std::integral<T>. Quando T viene dedotto da un parametro passato per valore, come nell’esempio, un normale argomento double non soddisfa il vincolo. È un controllo del tipo, non un controllo generale della convertibilità.

std::signed_integral e std::unsigned_integral distinguono inoltre il segno. Attenzione: bool soddisfa std::unsigned_integral e la classificazione del segno di char dipende dall’implementazione. std::integral da solo, quindi, non esclude i valori booleani né i caratteri; aggiungi vincoli separati se il tuo algoritmo non può gestirli.

Esempi

#include <concepts>
#include <iostream>

enum Number { one = 1 };

static_assert(std::integral<int>);
static_assert(std::integral<const volatile int>);
static_assert(std::integral<bool>);
static_assert(std::integral<char>);
static_assert(!std::integral<int&>);
static_assert(!std::integral<double>);
static_assert(!std::integral<Number>);

template<std::integral T>
constexpr bool is_even(T value) {
    return value % 2 == 0;
}

int main() {
    std::cout << std::boolalpha
              << is_even(42) << ' '
              << is_even(7u) << '\n';
}

Risultato

true false

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti