Baza znanjaIzpitno središče
SLSlovenščina
Izberi jezik13

CKTIS / C++

Celoštevilska napredovanja

Loči tip izračuna z `std::uint8_t` in `std::uint16_t` od ciljnega tipa. Loči tudi izpis števila od izpisa znaka.

Različica: ISO C++23; implementation support may vary

Sintaksa

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

V C++23 vgrajeno seštevanje celih števil sledi običajnim aritmetičnim pretvorbam: najprej uporabi celoštevilska napredovanja, nato določi skupni tip operandov. Običajni nepredznačeni celoštevilski tip z nižjim rangom pretvorbe od int napreduje v int, če int lahko predstavi vse njegove vrednosti, sicer v unsigned int. Tipska vzdevka std::uint8_t in std::uint16_t iz <cstdint> nista obvezna. Če sta na voljo, std::uint8_t napreduje v int, std::uint16_t pa napreduje v int, če ta lahko predstavi 65535. Sicer ima operand tipa std::uint16_t po napredovanjih tip unsigned int: bodisi napreduje v ta tip bodisi ga že ima.

Če imata a in b tip std::uint8_t ter vrednosti 250 in 10, je rezultat izraza a + b vrednost 260 tipa int. Šele poznejša pretvorba static_cast<std::uint8_t>(a + b) da 4, torej 260 po modulu 256. Ciljni tip ne spremeni načina izračuna vsote.

Če je std::uint8_t vzdevek za unsigned char, std::cout << byte izbere preobremenitev za izpis znaka, ne števila. Za izpis številske vrednosti uporabi std::cout << static_cast<unsigned int>(byte).

V a + 1u operand a še vedno napreduje v int. Literal 1u je tipa unsigned int, zato običajne aritmetične pretvorbe izberejo unsigned int kot skupni tip.

Primeri

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

Rezultat

260
4
1024
A

Pričakovane vrstice pokažejo vsoto `260`, pretvorjeno vrednost `4`, izpisano kot število, vsoto `1024` 16-bitnih operandov in znak `A`, izpisan s preobremenitvijo za `unsigned char`.

Povezane lekcije

  • C++ · Lekcija 17 · Napredna · Različica: 3

Viri