KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

std::integral — integer typen beperken

std::integral uit <concepts> controleert tijdens het compileren of een type een integer is. Het omvat ook bool en tekentypen en behoudt het resultaat bij const- en volatile-kwalificatie, maar wijst verwijzingen, enumeraties en typen met drijvende komma af.

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

Syntax

#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> is een concept uit <concepts>, gedefinieerd als std::is_integral_v<T>. Het controleert tijdens het compileren een typecategorie, niet de waarde van een argument: double voldoet er niet aan, zelfs niet wanneer het 4.0 bevat.

Het concept omvat signed en unsigned integer-typen, evenals bool en tekentypen zoals char en wchar_t. Enumeratietypen en klassen voldoen er niet alleen aan omdat ze naar int kunnen worden omgezet. De kwalificaties const en volatile veranderen het resultaat niet: std::integral<const int> is waar. Verwijzingen zijn echter geen integer-typen, dus std::integral<int&> is onwaar.

Gebruik template<std::integral T> om het typeargument T te beperken; je kunt ook template<class T> requires std::integral<T> schrijven. Wanneer T wordt afgeleid van een parameter die op waarde wordt doorgegeven, zoals in het voorbeeld, voldoet een gewoon double-argument niet aan de beperking. Dit is een typecontrole, geen algemene controle op converteerbaarheid.

std::signed_integral en std::unsigned_integral maken daarnaast onderscheid naar teken. Let op: bool voldoet aan std::unsigned_integral, en de tekenclassificatie van char hangt af van de implementatie. std::integral sluit booleaanse waarden of tekens dus niet op zichzelf uit; voeg aparte beperkingen toe als je algoritme ze niet aankan.

Voorbeelden

#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';
}

Resultaat

true false

De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.

Bronnen