WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

std::integral — Integer-Typen einschränken

std::integral aus <concepts> prüft zur Compile-Zeit, ob ein Typ ganzzahlig ist. Das Konzept umfasst auch bool und Zeichentypen und bleibt bei const- und volatile-Qualifizierung wahr, lehnt aber Referenzen, Aufzählungen und Gleitkommatypen ab.

Version: 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> ist ein Konzept aus <concepts> und als std::is_integral_v<T> definiert. Es prüft zur Compile-Zeit eine Typkategorie, nicht den Wert eines Arguments: double erfüllt das Konzept auch dann nicht, wenn darin 4.0 gespeichert ist.

Das Konzept umfasst vorzeichenbehaftete und vorzeichenlose Integer-Typen sowie bool und Zeichentypen wie char und wchar_t. Aufzählungstypen und Klassen erfüllen es nicht allein deshalb, weil sie in int konvertiert werden können. Die Qualifizierer const und volatile ändern das Ergebnis nicht: std::integral<const int> ist wahr. Referenzen sind jedoch keine ganzzahligen Typen, daher ist std::integral<int&> falsch.

Mit template<std::integral T> schränkst du das Typargument T ein; alternativ kannst du template<class T> requires std::integral<T> schreiben. Wird T wie im Beispiel aus einem Wertparameter abgeleitet, erfüllt ein gewöhnliches double-Argument die Einschränkung nicht. Dies ist eine Typprüfung und keine allgemeine Prüfung der Konvertierbarkeit.

std::signed_integral und std::unsigned_integral unterscheiden zusätzlich nach dem Vorzeichen. Achtung: bool erfüllt std::unsigned_integral, und die Vorzeichenklassifizierung von char hängt von der Implementierung ab. std::integral allein schließt daher boolesche Werte oder Zeichen nicht aus; füge eigene Einschränkungen hinzu, wenn dein Algorithmus sie nicht verarbeiten kann.

Beispiele

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

Ergebnis

true false

Der angezeigte Code und das angegebene Ergebnis wurden in einer isolierten Umgebung mit der im Prüfnachweis für genau diese Version dokumentierten Methode verifiziert.

Quellen