Share via

<bit>, funkcje

  • Artykuł

Nagłówek <bit> zawiera następujące funkcje szablonów innych niż składowe:

Funkcje inne niż składowe Opis
bit_cast Zinterpretuj ponownie reprezentację obiektu z jednego typu na inny.
bit_ceil Znajdź najmniejszą moc dwóch większej lub równej wartości.
bit_floor Znajdź największą moc dwóch wartości, które nie są większe niż wartość.
bit_width Znajdź najmniejszą liczbę bitów potrzebnych do reprezentowania wartości.
countl_zero Zlicz liczbę kolejnych bitów ustawionych na zero, zaczynając od najbardziej znaczącego bitu.
countl_one Zlicz liczbę kolejnych bitów ustawionych na jeden, zaczynając od najbardziej znaczącego bitu.
countr_zero Zlicz liczbę kolejnych bitów ustawionych na zero, zaczynając od najmniej znaczącego bitu.
countr_one Zlicz liczbę kolejnych bitów ustawionych na jeden, zaczynając od najmniej znaczącego bitu.
has_single_bit Sprawdź, czy wartość ma tylko jeden bit ustawiony na jeden. Jest to takie samo, jak testowanie, czy wartość jest potęgą dwóch.
popcount Zlicz liczbę bitów ustawioną na jedną.
rotl Oblicz wynik bitowej lewej rotacji.
rotr Oblicz wynik bitowej prawej rotacji.

bit_cast

Skopiuj wzorzec bitowy z obiektu typu From do nowego obiektu typu To.

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

Parametry

Do
Typ danych wyjściowych.

Od
Typ wartości do przekonwertowania.

Z
Wartość do konwersji.

Wartość zwracana

Obiekt typu To.

Każdy bit w wyniku pasuje do odpowiedniego bitu w from , chyba że istnieją bity wypełnienia w To, w którym przypadku te bity w wyniku są nieokreślone.

Przykład

#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

Uwagi

Kod niskiego poziomu często musi interpretować obiekt jednego typu jako inny typ. Obiekt ponownie zinterpretowany ma taką samą reprezentację bitową jak oryginalna, ale jest innym typem.

Zamiast używać reinterpret_castmetody , lub memcpy(), bit_cast() jest lepszym sposobem na dokonanie tych konwersji. Jest lepiej, ponieważ:

  • bit_cast() Jest constexpr
  • bit_cast() wymaga, aby typy można było kopiować w sposób trywialny i mieć ten sam rozmiar. Zapobiega to potencjalnym problemom, które można napotkać, i reinterpret_castmemcpy ponieważ mogą one być używane do przypadkowo i niepoprawnie przekonwertować typy nienależące do kopiowania. memcpy() Ponadto można użyć do przypadkowo skopiowania między typami, które nie są tego samego rozmiaru. Na przykład podwójne (8 bajtów) do niepodpisanej int (4 bajty) lub odwrotnie.

To przeciążenie uczestniczy tylko w rozwiązywaniu przeciążeń, jeśli:

Ten szablon funkcji ma constexpr wartość if i tylko wtedy, Fromgdy To, i typy ich podobiektów to:

  • Nie jest typem unii lub wskaźnika
  • Nie wskaźnik typu elementu członkowskiego
  • Nietrwałe kwalifikowane
  • Brak statycznego elementu członkowskiego danych, który jest typem referencyjnym

bit_ceil

Znajdź najmniejszą moc dwóch większej lub równej wartości. Na przykład podana wartość 3zwraca wartość 4.

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

Parametry

value
Wartość niepodpisanej liczby całkowitej do przetestowania.

Wartość zwracana

Najmniejsza moc dwóch większej lub równej value.

Przykład

#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

Uwagi

Ta funkcja szablonu uczestniczy tylko w rozwiązywaniu przeciążeń, jeśli T jest niepodpisanym typem liczb całkowitych. Na przykład: unsigned int, , unsigned shortunsigned long, unsigned chari tak dalej.

bit_floor

Znajdź największą moc dwóch wartości, które nie są większe niż wartość. Na przykład podana wartość 5zwraca wartość 4.

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

Parametry

value
Wartość niepodpisanej liczby całkowitej do przetestowania.

Wartość zwracana

Największa moc dwóch, która nie jest większa niż value.
Jeśli value ma wartość zero, zwraca zero.

Przykład

#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

Uwagi

Ta funkcja szablonu uczestniczy tylko w rozwiązywaniu przeciążeń, jeśli T jest niepodpisanym typem liczb całkowitych. Na przykład: unsigned int, , unsigned shortunsigned long, unsigned chari tak dalej.

bit_width

Znajdź najmniejszą liczbę bitów potrzebnych do reprezentowania wartości.

Na przykład w przypadku wartości 5 (0b101) zwraca wartość 3, ponieważ wyrażenie wartości 5 wymaga 3 bitów binarnych.

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

Parametry

value
Wartość niepodpisanej liczby całkowitej do przetestowania.

Wartość zwracana

Liczba bitów wymaganych do reprezentowania value.
Jeśli value ma wartość zero, zwraca zero.

Przykład

#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

Uwagi

Ta funkcja szablonu uczestniczy tylko w rozwiązywaniu przeciążeń, jeśli T jest niepodpisanym typem liczb całkowitych. Na przykład: unsigned int, , unsigned shortunsigned long, unsigned chari tak dalej.

countl_zero

Zlicz liczbę kolejnych bitów ustawionych na zero, zaczynając od najbardziej znaczącego bitu.

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

Parametry

value
Wartość niepodpisanej liczby całkowitej do przetestowania.

Wartość zwracana

Liczba kolejnych bitów zerowych, zaczynając od najbardziej znaczącego bitu.
Jeśli value ma wartość zero, liczba bitów w typie value.

Przykład

#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

Uwagi

Ta funkcja szablonu uczestniczy tylko w rozwiązywaniu przeciążeń, jeśli T jest niepodpisanym typem liczb całkowitych. Na przykład: unsigned int, , unsigned shortunsigned long, unsigned chari tak dalej.

countl_one

Zlicz liczbę kolejnych bitów ustawionych na jeden, zaczynając od najbardziej znaczącego bitu.

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

Parametry

value
Wartość niepodpisanej liczby całkowitej do przetestowania.

Wartość zwracana

Liczba kolejnych bitów ustawiona na jedną, zaczynając od najbardziej znaczącego bitu.

Przykład

#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

Uwagi

Ta funkcja szablonu uczestniczy tylko w rozwiązywaniu przeciążeń, jeśli T jest niepodpisanym typem liczb całkowitych. Na przykład: unsigned int, , unsigned shortunsigned long, unsigned chari tak dalej.

countr_zero

Zlicz liczbę kolejnych bitów ustawionych na zero, zaczynając od najmniej znaczącego bitu.

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

Parametry

value
Wartość niepodpisanej liczby całkowitej do przetestowania.

Wartość zwracana

Liczba kolejnych bitów zerowych, zaczynając od najmniej znaczącego bitu.
Jeśli value ma wartość zero, liczba bitów w typie value.

Przykład

#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

Uwagi

Ta funkcja szablonu uczestniczy tylko w rozwiązywaniu przeciążeń, jeśli T jest niepodpisanym typem liczb całkowitych. Na przykład: unsigned int, , unsigned shortunsigned long, unsigned chari tak dalej.

countr_one

Zlicz liczbę kolejnych bitów ustawionych na jeden, zaczynając od najmniej znaczącego bitu.

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

Parametry

value
Wartość niepodpisanej liczby całkowitej do przetestowania.

Wartość zwracana

Liczba kolejnych bitów ustawiona na jedną, zaczynając od najmniej znaczącego bitu.

Przykład

#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

Uwagi

Ta funkcja szablonu uczestniczy tylko w rozwiązywaniu przeciążeń, jeśli T jest niepodpisanym typem liczb całkowitych. Na przykład: unsigned int, , unsigned shortunsigned long, unsigned chari tak dalej.

has_single_bit

Sprawdź, czy wartość ma tylko jeden zestaw bitowy. Jest to takie samo, jak testowanie, czy wartość jest potęgą dwóch.

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

Parametry

value
Wartość niepodpisanej liczby całkowitej do przetestowania.

Wartość zwracana

true jeśli value ma tylko jeden zestaw bitowy, co oznacza również, że value jest to moc dwóch. W przeciwnym razie wartość false.

Przykład

#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

Uwagi

Ta funkcja szablonu uczestniczy tylko w rozwiązywaniu przeciążeń, jeśli T jest niepodpisanym typem liczb całkowitych. Na przykład: unsigned int, , unsigned shortunsigned long, unsigned chari tak dalej.

popcount

Zlicz liczbę bitów ustawioną na jedną w niepodpisanej wartości całkowitej.

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

Parametry

value
Wartość niepodpisanej liczby całkowitej do przetestowania.

Wartość zwracana

Bity liczbowe ustawione na jeden w valueelem.

Przykład

#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

Uwagi

Ta funkcja szablonu uczestniczy tylko w rozwiązywaniu przeciążeń, jeśli T jest niepodpisanym typem liczb całkowitych. Na przykład: unsigned int, , unsigned shortunsigned long, unsigned chari tak dalej.

rotl

Obraca bity niepodpisanej wartości całkowitej pozostawionej określoną liczbę razy. Bity, które "wypadają" z lewego bitu, są obracane w najbardziej prawy bit.

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

Parametry

value
Wartość niepodpisanej liczby całkowitej, która ma być obracana.

s
Liczba rotacji po lewej stronie do wykonania.

Wartość zwracana

Wynik rotacji value w lewo, s czasy.
Jeśli s wartość to zero, zwraca wartość value.
Jeśli s wartość jest ujemna, czy .rotr(value, -s) Bity, które "wypadają" z prawej części bitu, są obracane w najbardziej lewy bit.

Przykład

#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

Uwagi

Ta funkcja szablonu uczestniczy tylko w rozwiązywaniu przeciążeń, jeśli T jest niepodpisanym typem liczb całkowitych. Na przykład: unsigned int, , unsigned shortunsigned long, unsigned chari tak dalej.

rotr

Obraca bity value po prawej stronie określoną liczbę razy. Bity, które "wypadają" z prawej części bitu, są obracane z powrotem do lewego bitu.

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

Parametry

value
Wartość niepodpisanej liczby całkowitej, która ma być obracana.

s
Liczba prawidłowych rotacji do wykonania.

Wartość zwracana

Wynik rotacji value w prawo, s czasy.
Jeśli s wartość to zero, zwraca wartość value.
Jeśli s wartość jest ujemna, czy .rotl(value, -s) Bity, które "wypadają" z lewego bitu, są obracane z powrotem do najbardziej prawego bitu.

Przykład

#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

Uwagi

Ta funkcja szablonu uczestniczy tylko w rozwiązywaniu przeciążeń, jeśli T jest niepodpisanym typem liczb całkowitych. Na przykład: unsigned int, , unsigned shortunsigned long, unsigned chari tak dalej.

Wymagania

Nagłówka:<bit>

Przestrzeń nazw: std

/std:c++20 lub nowszy jest wymagany.

Zobacz też

<bit>