Sdílet prostřednictvím

<bit> – funkce

  • Článek

Hlavička <bit> obsahuje následující funkce šablony, které nejsou členy:

Nečlenové funkce Popis
bit_cast Reinterpretujte reprezentaci objektu z jednoho typu do druhého.
bit_ceil Najde nejmenší mocninu dvou větších nebo rovnajících se hodnotě.
bit_floor Najděte největší mocninu dvou ne větší než hodnotu.
bit_width Najděte nejmenší počet bitů potřebných k vyjádření hodnoty.
countl_zero Spočítejte počet po sobě jdoucích bitů nastavených na nulu počínaje nejvýznamnějším bitem.
countl_one Spočítejte počet po sobě jdoucích bitů nastavených na jeden, počínaje nejvýznamnějším bitem.
countr_zero Spočítejte počet po sobě jdoucích bitů nastavených na nulu počínaje nejméně významným bitem.
countr_one Spočítejte počet po sobě jdoucích bitů nastavených na jednu, počínaje nejméně významným bitem.
has_single_bit Zkontrolujte, jestli má hodnota nastavenou jenom jednu bitovou hodnotu. To je stejné jako testování, jestli je hodnota výkonem dvou.
popcount Spočítejte počet bitů nastavených na jednu.
rotl Vypočítá výsledek bitové levé rotace.
rotr Vypočítá výsledek bitové pravé rotace.

bit_cast

Zkopírujte bitový vzor z objektu typu From do nového objektu typu To.

template <class To, class From>
[[nodiscard]] constexpr To bit_cast(const From& from) noexcept;

Parametry

Na
Typ výstupu.

Od
Typ hodnoty, kterou chcete převést.

od
Hodnota, kterou chcete převést.

Vrácená hodnota

Objekt typu To.

Každý bit ve výsledku odpovídá odpovídajícímu bitu, from pokud neexistují odsazení bitů , Tov takovém případě tyto bity ve výsledku nejsou zadané.

Příklad

#include <bit>
#include <iostream>

int main()
{
    float f = std::numeric_limits<float>::infinity();
    int i = std::bit_cast<int>(f);
    std::cout << "float f = " << std::hex << f
              << "\nstd::bit_cast<int>(f) = " << std::hex << i << '\n';
    return 0;
}

float f = inf
std::bit_cast<int>(f) = 7f800000

Poznámky

Kód nízké úrovně často potřebuje interpretovat objekt jednoho typu jako jiný typ. Reinterpretovaný objekt má stejnou bitovou reprezentaci jako původní objekt, ale je jiný typ.

Místo použití reinterpret_castnebo memcpy()bit_cast() je lepší způsob, jak tyto převody provést. Je lepší, protože:

  • bit_cast() je constexpr
  • bit_cast() vyžaduje triviálně kopírovatelné typy a stejnou velikost. Tím se zabrání potenciálním problémům, se kterými byste se mohli setkat, reinterpret_cast a memcpy protože je možné je použít k neúmyslné a nesprávné převodu neschválných typů. memcpy() Můžete také použít k neúmyslné kopírování mezi typy, které nemají stejnou velikost. Například dvojitá (8 bajtů) do bez znaménka (4 bajty) nebo naopak.

Toto přetížení se účastní pouze rozlišení přetížení, pokud:

Tato šablona funkce jeconstexpr, pokud a pouze pokud FromTo, a typy jejich podobjektů jsou:

  • Ne sjednocení nebo typ ukazatele
  • Není ukazatel na typ členu.
  • Nevolatilně kvalifikovaný
  • Nemá žádný nestatický datový člen, který je odkazovým typem

bit_ceil

Najde nejmenší mocninu dvou větších nebo rovnajících se hodnotě. Například dané 3, vrátí 4.

template<class T>
[[nodiscard]] constexpr T bit_ceil(T value);

Parametry

value
Celočíselná hodnota bez znaménka, která se má testovat.

Vrácená hodnota

Nejmenší mocnina dvou větších nebo rovna value.

Příklad

#include <bit>
#include <bitset>
#include <iostream>

int main()
{
    for (auto i = 0u; i < 6u; ++i) // bit_ceil() takes an unsigned integer type
    {
        auto nextClosestPowerOf2 = std::bit_ceil(i);
        std::cout << "\nbit_ceil(0b" << std::bitset<4>(i) << ") = "
                  << "0b" << std::bitset<4>(nextClosestPowerOf2);
    }
    return 0;
}

bit_ceil(0b0000) = 0b0001
bit_ceil(0b0001) = 0b0001
bit_ceil(0b0010) = 0b0010
bit_ceil(0b0011) = 0b0100
bit_ceil(0b0100) = 0b0100
bit_ceil(0b0101) = 0b1000

Poznámky

Tato funkce šablony se účastní rozlišení přetížení pouze v případě T , že je celočíselného typu bez znaménka. Například: unsigned int, , unsigned longunsigned short, unsigned charatd.

bit_floor

Najděte největší mocninu dvou ne větší než hodnotu. Například dané 5, vrátí 4.

template< class T >
[[nodiscard]] constexpr T bit_floor(T value) noexcept;

Parametry

value
Celočíselná hodnota bez znaménka, která se má testovat.

Vrácená hodnota

Největší mocnina dvou, která není větší než value.
Pokud value je nula, vrátí nulu.

Příklad

#include <bit>
#include <bitset>
#include <iostream>

int main()
{
    for (auto i = 0u; i < 6u; ++i) // bit_floor() takes an unsigned integer type
    {
        auto previousPowerOf2 = std::bit_floor(i);
        std::cout << "\nbit_floor(0b" << std::bitset<4>(i) << ") = 0b"
                  << std::bitset<4>(previousPowerOf2);
    }
    return 0;
}

bit_floor(0b0000) = 0b0000
bit_floor(0b0001) = 0b0001
bit_floor(0b0010) = 0b0010
bit_floor(0b0011) = 0b0010
bit_floor(0b0100) = 0b0100
bit_floor(0b0101) = 0b0100

Poznámky

Tato funkce šablony se účastní rozlišení přetížení pouze v případě T , že je celočíselného typu bez znaménka. Například: unsigned int, , unsigned longunsigned short, unsigned charatd.

bit_width

Najděte nejmenší počet bitů potřebných k vyjádření hodnoty.

Například s hodnotou 5 (0b101) vrátí hodnotu 3, protože k vyjádření hodnoty 5 trvá 3 binární bity.

template<class T>
[[nodiscard]] constexpr T bit_width(T value) noexcept;

Parametry

value
Celočíselná hodnota bez znaménka, která se má testovat.

Vrácená hodnota

Počet bitů potřebných k reprezentaci value.
Pokud value je nula, vrátí nulu.

Příklad

#include <bit>
#include <iostream>

int main()
{
    for (unsigned i=0u; i <= 8u; ++i)
    {
        std::cout << "\nbit_width(" << i << ") = "
                  << std::bit_width(i);
    }
    return 0;
}

bit_width(0) = 0
bit_width(1) = 1
bit_width(2) = 2
bit_width(3) = 2
bit_width(4) = 3
bit_width(5) = 3
bit_width(6) = 3
bit_width(7) = 3
bit_width(8) = 4

Poznámky

Tato funkce šablony se účastní rozlišení přetížení pouze v případě T , že je celočíselného typu bez znaménka. Například: unsigned int, , unsigned longunsigned short, unsigned charatd.

countl_zero

Spočítejte počet po sobě jdoucích bitů nastavených na nulu počínaje nejvýznamnějším bitem.

template<class T>
[[nodiscard]] constexpr int countl_zero(T value) noexcept;

Parametry

value
Celočíselná hodnota bez znaménka, která se má testovat.

Vrácená hodnota

Počet posoběch
Pokud value je nula, počet bitů v typu value.

Příklad

#include <bit>
#include <bitset>
#include <iostream>

int main()
{
    for (unsigned char result = 0, i = 0; i < 9; i++)
    {
        std::cout << "\ncountl_zero(0b" << std::bitset<8>(result) << ") = " << std::countl_zero(result);
        result = result == 0 ? 1 : result * 2;
    }
    return 0;
}

countl_zero(0b00000000) = 8
countl_zero(0b00000001) = 7
countl_zero(0b00000010) = 6
countl_zero(0b00000100) = 5
countl_zero(0b00001000) = 4
countl_zero(0b00010000) = 3
countl_zero(0b00100000) = 2
countl_zero(0b01000000) = 1
countl_zero(0b10000000) = 0

Poznámky

Tato funkce šablony se účastní rozlišení přetížení pouze v případě T , že je celočíselného typu bez znaménka. Například: unsigned int, , unsigned longunsigned short, unsigned charatd.

countl_one

Spočítejte počet po sobě jdoucích bitů nastavených na jeden, počínaje nejvýznamnějším bitem.

template<class T>
[[nodiscard]] constexpr int countl_one(T value) noexcept;

Parametry

value
Celočíselná hodnota bez znaménka, která se má testovat.

Vrácená hodnota

Počet posoběch

Příklad

#include <bit>
#include <bitset>
#include <iostream>

int main()
{
    unsigned char value = 0;
    for (unsigned char bit = 128; bit > 0; bit /= 2)
    {
        value |= bit;
        std::cout << "\ncountl_one(0b" << std::bitset<8>(value) << ") = "
                  << std::countl_one(value);
    }
    return 0;
}

countl_one(0b10000000) = 1
countl_one(0b11000000) = 2
countl_one(0b11100000) = 3
countl_one(0b11110000) = 4
countl_one(0b11111000) = 5
countl_one(0b11111100) = 6
countl_one(0b11111110) = 7
countl_one(0b11111111) = 8

Poznámky

Tato funkce šablony se účastní rozlišení přetížení pouze v případě T , že je celočíselného typu bez znaménka. Například: unsigned int, , unsigned longunsigned short, unsigned charatd.

countr_zero

Spočítejte počet po sobě jdoucích bitů nastavených na nulu počínaje nejméně významným bitem.

template<class T>
[[nodiscard]] constexpr int countr_zero(T value) noexcept;

Parametry

value
Celočíselná hodnota bez znaménka, která se má testovat.

Vrácená hodnota

Počet po sobě jdoucích nul bitů počínaje nejméně významným bitem.
Pokud value je nula, počet bitů v typu value.

Příklad

#include <bit>
#include <bitset>
#include <iostream>

int main()
{
    for (unsigned char result = 0, i = 0; i < 9; i++)
    {
        std::cout << "\ncountr_zero(0b" << std::bitset<8>(result) << ") = "
                  << std::countr_zero(result);
        result = result == 0 ? 1 : result * 2;
    }
    return 0;
}

countr_zero(0b00000000) = 8
countr_zero(0b00000001) = 0
countr_zero(0b00000010) = 1
countr_zero(0b00000100) = 2
countr_zero(0b00001000) = 3
countr_zero(0b00010000) = 4
countr_zero(0b00100000) = 5
countr_zero(0b01000000) = 6
countr_zero(0b10000000) = 7

Poznámky

Tato funkce šablony se účastní rozlišení přetížení pouze v případě T , že je celočíselného typu bez znaménka. Například: unsigned int, , unsigned longunsigned short, unsigned charatd.

countr_one

Spočítejte počet po sobě jdoucích bitů nastavených na jednu, počínaje nejméně významným bitem.

template<class T>
[[nodiscard]] constexpr int countr_one(T value) noexcept;

Parametry

value
Celočíselná hodnota bez znaménka, která se má testovat.

Vrácená hodnota

Počet posoběch

Příklad

#include <bit>
#include <bitset>
#include <iostream>

int main()
{
    unsigned char value = 0;
    for (int bit = 1; bit <= 128; bit *= 2)
    {
        value |= bit;
        std::cout << "\ncountr_one(0b" << std::bitset<8>(value) << ") = "
                  << std::countr_one(value);
    }
    return 0;
}

countr_one(0b00000001) = 1
countr_one(0b00000011) = 2
countr_one(0b00000111) = 3
countr_one(0b00001111) = 4
countr_one(0b00011111) = 5
countr_one(0b00111111) = 6
countr_one(0b01111111) = 7
countr_one(0b11111111) = 8

Poznámky

Tato funkce šablony se účastní rozlišení přetížení pouze v případě T , že je celočíselného typu bez znaménka. Například: unsigned int, , unsigned longunsigned short, unsigned charatd.

has_single_bit

Zkontrolujte, jestli má hodnota nastavenou jenom jednu bitovou sadu. To je stejné jako testování, jestli je hodnota výkonem dvou.

template <class T>
[[nodiscard]] constexpr bool has_single_bit(T value) noexcept;

Parametry

value
Celočíselná hodnota bez znaménka, která se má testovat.

Vrácená hodnota

true pokud value má pouze jednu bitovou sadu, což také znamená, že value je to mocnina dvou. V opačném případě hodnota false.

Příklad

#include <bit>
#include <bitset>
#include <iostream>
#include <iomanip>

int main()
{
    for (auto i = 0u; i < 10u; ++i)
    {
        std::cout << "has_single_bit(0b" << std::bitset<4>(i) << ") = "
                  << std::boolalpha << std::has_single_bit(i) << '\n';
    }
    return 0;
}

has_single_bit(0b0000) = false
has_single_bit(0b0001) = true
has_single_bit(0b0010) = true
has_single_bit(0b0011) = false
has_single_bit(0b0100) = true
has_single_bit(0b0101) = false
has_single_bit(0b0110) = false
has_single_bit(0b0111) = false
has_single_bit(0b1000) = true
has_single_bit(0b1001) = false

Poznámky

Tato funkce šablony se účastní rozlišení přetížení pouze v případě T , že je celočíselného typu bez znaménka. Například: unsigned int, , unsigned longunsigned short, unsigned charatd.

popcount

Spočítejte počet bitů nastavených na jeden v celočíselné hodnotě bez znaménka.

template<class T>
[[nodiscard]] constexpr int popcount(T value) noexcept;

Parametry

value
Celočíselná hodnota bez znaménka, která se má testovat.

Vrácená hodnota

Počet bitů nastavený na hodnotu 1 v value.

Příklad

#include <bit>
#include <bitset>
#include <iostream>

int main()
{
   for (unsigned char value = 0; value < 16; value++)
    {
        std::cout << "\npopcount(0b" << std::bitset<4>(value) << ") = "
                  << std::popcount(value);
    }
    return 0;
}

popcount(0b0000) = 0
popcount(0b0001) = 1
popcount(0b0010) = 1
popcount(0b0011) = 2
popcount(0b0100) = 1
popcount(0b0101) = 2
popcount(0b0110) = 2
popcount(0b0111) = 3
popcount(0b1000) = 1
popcount(0b1001) = 2
popcount(0b1010) = 2
popcount(0b1011) = 3
popcount(0b1100) = 2
popcount(0b1101) = 3
popcount(0b1110) = 3
popcount(0b1111) = 4

Poznámky

Tato funkce šablony se účastní rozlišení přetížení pouze v případě T , že je celočíselného typu bez znaménka. Například: unsigned int, , unsigned longunsigned short, unsigned charatd.

rotl

Obměna bitů celočíselné hodnoty bez znaménka ponechá zadaný počet opakování. Bity, které "vypadnou" z levého bitu, se otočí do pravé části.

template<class T>
[[nodiscard]] constexpr T rotl(T value, int s) noexcept;

Parametry

value
Celočíselná hodnota bez znaménka, kterou chcete otočit.

s
Počet levých otočení, které se mají provést.

Vrácená hodnota

Výsledek otáčení value doleva, s časy.
Pokud s je nula, vrátí hodnotu value.
Je-li s záporné, dělá rotr(value, -s). Bity, které "vypadnou" z pravé části, se otočí do levého bitového bitového rohu.

Příklad

#include <bit>
#include <bitset>
#include <iostream>

int main()
{
    unsigned char bits = 1;
    for (int i = 0; i < 8; ++i)
    {
        std::cout << "rotl(0b" << std::bitset<8>(bits) << ", 1) = ";
        bits = std::rotl(bits, 1);
        std::cout << "0b" << std::bitset<8>(bits) << '\n';
    }
    std::cout << "rotl(0b" << std::bitset<8>(bits) << ",-1) = ";
    bits = std::rotl(bits, -1);
    std::cout << "0b" << std::bitset<8>(bits);
    return 0;
}

rotl(0b00000001, 1) = 0b00000010
rotl(0b00000010, 1) = 0b00000100
rotl(0b00000100, 1) = 0b00001000
rotl(0b00001000, 1) = 0b00010000
rotl(0b00010000, 1) = 0b00100000
rotl(0b00100000, 1) = 0b01000000
rotl(0b01000000, 1) = 0b10000000
rotl(0b10000000, 1) = 0b00000001
rotl(0b00000001,-1) = 0b10000000

Poznámky

Tato funkce šablony se účastní rozlišení přetížení pouze v případě T , že je celočíselného typu bez znaménka. Například: unsigned int, , unsigned longunsigned short, unsigned charatd.

rotr

Otočí bity value doprava zadaný početkrát. Bity, které "vypadnou" z pravé části, se otočí zpět do levé části.

template<class T>
[[nodiscard]] constexpr T rotr(T value, int s) noexcept;

Parametry

value
Celočíselná hodnota bez znaménka, kterou chcete otočit.

s
Počet správných otočení, které se mají provést.

Vrácená hodnota

Výsledek otáčení value doprava, s časy.
Pokud s je nula, vrátí hodnotu value.
Je-li s záporné, dělá rotl(value, -s). Bity, které "vypadnou" z levého bitu, se otočí zpět do pravé části.

Příklad

#include <bit>
#include <bitset>
#include <iostream>

int main()
{
    unsigned char bits = 128;
    for (int i = 0; i < 8; ++i)
    {
        std::cout << "rotr(0b" << std::bitset<8>(bits) << ", 1) = ";
        bits = std::rotr(bits, 1);
        std::cout << "0b" << std::bitset<8>(bits) << '\n';
    }
    std::cout << "rotr(0b" << std::bitset<8>(bits) << ",-1) = ";
    bits = std::rotr(bits, -1);
    std::cout << "0b" << std::bitset<8>(bits);
    return 0;
}

rotr(0b10000000, 1) = 0b01000000
rotr(0b01000000, 1) = 0b00100000
rotr(0b00100000, 1) = 0b00010000
rotr(0b00010000, 1) = 0b00001000
rotr(0b00001000, 1) = 0b00000100
rotr(0b00000100, 1) = 0b00000010
rotr(0b00000010, 1) = 0b00000001
rotr(0b00000001, 1) = 0b10000000
rotr(0b10000000,-1) = 0b00000001

Poznámky

Tato funkce šablony se účastní rozlišení přetížení pouze v případě T , že je celočíselného typu bez znaménka. Například: unsigned int, , unsigned longunsigned short, unsigned charatd.

Požadavky

Záhlaví: <bit>

Obor názvů: std

/std:c++20 nebo novější se vyžaduje.

Viz také

<bit>