WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

Ganzzahl-Promotions

Bestimme den Rechentyp für `std::uint8_t` und `std::uint16_t` getrennt vom Zieltyp. Unterscheide außerdem die Zeichen- von der Zahlenausgabe.

Version: ISO C++23; implementation support may vary

Syntax

a + b                         // built-in addition: promote operands, then find a common type
static_cast<std::uint8_t>(a + b) // convert the result, not the operands
std::cout << static_cast<unsigned int>(byte) // numeric output

Bei der eingebauten Ganzzahladdition in C++23 gelten die üblichen arithmetischen Konvertierungen: Zuerst werden Ganzzahl-Promotions angewandt, danach wird ein gemeinsamer Operandentyp bestimmt. Ein gewöhnlicher vorzeichenloser Ganzzahltyp mit niedrigerem Rang als int wird zu int promoviert, wenn int den gesamten Wertebereich abdeckt, andernfalls zu unsigned int. Die Aliase std::uint8_t und std::uint16_t aus <cstdint> sind optional. Falls vorhanden, wird std::uint8_t zu int promoviert, std::uint16_t dagegen nur, wenn int den Wert 65535 darstellen kann. Andernfalls hat der std::uint16_t-Operand nach den Promotions den Typ unsigned int: Entweder wird er dorthin promoviert oder er hat den Typ bereits.

Sind a und b Werte vom Typ std::uint8_t mit den Werten 250 und 10, ergibt a + b den Wert 260 vom Typ int. Erst die anschließende Umwandlung static_cast<std::uint8_t>(a + b) ergibt 4, also 260 modulo 256. Der Zieltyp ändert die Berechnung der Summe nicht.

Ist std::uint8_t ein Alias für unsigned char, wählt std::cout << byte eine Zeichenüberladung und keine numerische Überladung. std::cout << static_cast<unsigned int>(byte) gibt den Zahlenwert aus.

In a + 1u wird a weiterhin zu int promoviert. Das Literal 1u hat den Typ unsigned int. Daher ergibt sich bei den üblichen arithmetischen Konvertierungen unsigned int als gemeinsamer Typ.

Beispiele

#include <cstdint>
#include <iostream>
#include <limits>
#include <type_traits>

int main() {
    constexpr std::uint8_t a = 0xFAu, b = 10;
    constexpr auto sum = a + b;
    constexpr auto byte = static_cast<std::uint8_t>(sum);
    static_assert(std::is_same_v<decltype(a + b), int>);
    static_assert(sum == 260 && byte == 4);

    constexpr std::uint16_t x = 1000, y = 24;
    using Sum16 = std::conditional_t<(std::numeric_limits<int>::digits >= 16),
                                     int, unsigned int>;
    static_assert(std::is_same_v<decltype(x + y), Sum16>);

    const unsigned char letter = 'A';
    std::cout << sum << '\n'
              << static_cast<unsigned int>(byte) << '\n'
              << x + y << '\n'
              << letter << '\n';
}

Ergebnis

260
4
1024
A

Die erwarteten Zeilen zeigen die Summe `260`, den numerisch ausgegebenen umgewandelten Wert `4`, die Summe `1024` der 16-Bit-Operanden und das über die Überladung für `unsigned char` ausgegebene Zeichen `A`.

Zugehörige Lektionen

  • C++ · Lektion 17 · Fortgeschritten · Version: 3

Quellen