`<bit>`Функции

Заголовок <bit> включает следующие функции шаблона, отличные от членов:

Функции, не являющиеся членами	Description
`bit_cast`	Переосмысление представления объекта из одного типа в другой.
`bit_ceil`	Найдите наименьшую мощность двух больше или равно значению.
`bit_floor`	Найдите самую большую мощность из двух значений, не превышающих значение.
`bit_width`	Найдите наименьшее количество битов, необходимых для представления значения.
`countl_zero`	Подсчитывать число последовательных битов, равное нулю, начиная с самого значительного бита.
`countl_one`	Подсчитывать число последовательных битов, установленных на один, начиная с самого значительного бита.
`countr_zero`	Подсчитывать число последовательных битов, равное нулю, начиная с наименьшего значительного бита.
`countr_one`	Подсчитывает количество последовательных битов, начиная с наименьшего значительного бита.
`has_single_bit`	Проверьте, имеет ли значение только один бит. Это то же самое, что и проверка того, является ли значение двумя.
`popcount`	Подсчитывать число битов, установленных на один.
`rotl`	Вычислить результат побитового поворота влево.
`rotr`	Вычислить результат побитового поворота вправо.

`bit_cast`

Скопируйте битовый шаблон из объекта типа From в новый объект типа To.

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

Параметры

Кому
Тип выходных данных.

From
Тип, в который нужно преобразовать значение.

from
Преобразуемое значение .

Возвращаемое значение

Объект типа To.

Каждый бит в результате соответствует соответствующему биту, from если в результатах нет битов с заполнением, в этом случае эти биты Toв результате не определены.

Пример

#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

Замечания

Код низкого уровня часто требует интерпретации объекта одного типа как другого типа. Повторно интерпретированный объект имеет то же битовое представление, что и исходный, но является другим типом.

Вместо использования reinterpret_castили memcpy()bit_cast() лучше сделать эти преобразования. Это лучше, потому что:

bit_cast() имеет значение constexpr.
bit_cast() требует, чтобы типы были тривиально копируемыми и одинаковыми. Это предотвращает потенциальные проблемы, с которыми можно столкнуться с помощью, reinterpret_cast и memcpy потому что они могут использоваться для непреднамеренного и неправильного преобразования нетривиально копируемых типов. Кроме того, memcpy() можно использовать для непреднамеренного копирования между типами, которые не совпадают с размером. Например, двойный (8 байт) в неназначенной инте (4 байта) или другой способ.

Эта перегрузка участвует только в разрешении перегрузки, если:

sizeof(To) == sizeof(From)
Toи From is_trivially_copyable.

Этот шаблон функции имеет значение constexpr , если и только Toесли , Fromи типы их вложенных объектов:

Не тип объединения или указателя
Не указатель на тип элемента
Не изменяющийся
Нет нестатитического элемента данных, являющегося ссылочным типом

`bit_ceil`

Найдите наименьшую мощность двух больше или равно значению. Например, при указании 3возвращается 4.

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

Параметры

value
Значение целого числа без знака для тестирования.

Возвращаемое значение

Наименьшая мощность двух больше или равно value.

Пример

#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

Замечания

Эта функция шаблона участвует только в разрешении перегрузки, если T это тип целого числа без знака. Например, unsigned int, unsigned long, unsigned shortunsigned charи т. д.

`bit_floor`

Найдите самую большую мощность из двух значений, не превышающих значение. Например, при указании 5возвращается 4.

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

Параметры

value
Значение целого числа без знака для тестирования.

Возвращаемое значение

Самая большая сила из двух, которые не больше value.
Если value значение равно нулю, возвращается ноль.

Пример

#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

Замечания

`bit_width`

Найдите наименьшее количество битов, необходимых для представления значения.

Например, если задано значение 5 (0b101), возвращается 3, так как для выражения значения 5 требуется 3 двоичных бита.

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

Параметры

value
Значение целого числа без знака для тестирования.

Возвращаемое значение

Количество битов, необходимых для представления value.
Если value значение равно нулю, возвращается ноль.

Пример

#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

Замечания

`countl_zero`

Подсчитывать число последовательных битов, равное нулю, начиная с самого значительного бита.

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

Параметры

value
Значение целого числа без знака для тестирования.

Возвращаемое значение

Число последовательных нулевых битов, начиная с самого значительного бита.
Если value значение равно нулю, число битов в типе value.

Пример

#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

Замечания

`countl_one`

Подсчитывать число последовательных битов, установленных на один, начиная с самого значительного бита.

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

Параметры

value
Значение целого числа без знака для тестирования.

Возвращаемое значение

Число последовательных битов, установленных на один, начиная с самого значительного бита.

Пример

#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

Замечания

`countr_zero`

Подсчитывать число последовательных битов, равное нулю, начиная с наименьшего значительного бита.

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

Параметры

value
Значение целого числа без знака для тестирования.

Возвращаемое значение

Число последовательных нулевых битов, начиная с наименьшего значительного бита.
Если value значение равно нулю, число битов в типе value.

Пример

#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

Замечания

`countr_one`

Подсчитывает количество последовательных битов, начиная с наименьшего значительного бита.

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

Параметры

value
Значение целого числа без знака для тестирования.

Возвращаемое значение

Число последовательных битов, установленных на один, начиная с наименьшего значительного бита.

Пример

#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

Замечания

`has_single_bit`

Проверьте, имеет ли значение только один бит. Это то же самое, что и проверка того, является ли значение двумя.

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

Параметры

value
Значение целого числа без знака для тестирования.

Возвращаемое значение

true Если value имеется только один битовый набор, то это также означает, что value это мощность двух. В противном случае — false.

Пример

#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

Замечания

`popcount`

Подсчитывайте число битов, установленных в одно целое число без знака.

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

Параметры

value
Значение целого числа без знака для тестирования.

Возвращаемое значение

Число битов, заданных для одного в value.

Пример

#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

Замечания

`rotl`

Поворот битов целого числа без знака оставил указанное количество раз. Биты, которые "выпадают" из крайнего левого бита, вращаются в самый правый бит.

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

Параметры

value
Целое число без знака для поворота.

s
Количество выполняемых поворотов влево.

Возвращаемое значение

Результат поворота value влево, s время.
Если s равно нулю, возвращается value.
Если s отрицательный, выполняется rotr(value, -s). Биты, которые "выпадают" из крайнего правого бита вращаются в самый левый бит.

Пример

#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

Замечания

`rotr`

Поворачивает биты value вправо по указанному количеству раз. Биты, которые "выпадают" из крайнего правого бита вращаются обратно в самый левый бит.

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

Параметры

value
Целое число без знака для поворота.

s
Количество выполняемых поворотов вправо.

Возвращаемое значение

Результат поворота value вправо, s время.
Если s равно нулю, возвращается value.
Если s отрицательный, выполняется rotl(value, -s). Биты, которые "выпадают" из крайнего левого бита, поворачиваются обратно в самый правый бит.

Пример

#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

Замечания

Требования

Заголовок: <bit>

Пространство имен: std

/std:c++20 или более поздней версии требуется.

См. также

<bit>

Обратная связь

Были ли сведения на этой странице полезными?

Last updated on 2025-11-07

Поделиться через

<bit>Функции

bit_cast

Параметры

Возвращаемое значение

Пример

Замечания

bit_ceil

Параметры

Возвращаемое значение

Пример

Замечания

bit_floor

Параметры

Возвращаемое значение

Пример

Замечания

bit_width

Параметры

Возвращаемое значение

Пример

Замечания

countl_zero

Параметры

Возвращаемое значение

Пример

Замечания

countl_one

Параметры

Возвращаемое значение

Пример

Замечания

countr_zero

Параметры

Возвращаемое значение

Пример

Замечания

countr_one

Параметры

Возвращаемое значение

Пример

Замечания

has_single_bit

Параметры

Возвращаемое значение

Пример

Замечания

popcount

Параметры

Возвращаемое значение

Пример

Замечания

rotl

Параметры

Возвращаемое значение

Пример

Замечания

rotr

Параметры

Возвращаемое значение

Пример

Замечания

Требования

См. также

Обратная связь

Дополнительные ресурсы

`<bit>`Функции

`bit_cast`

`bit_ceil`

`bit_floor`

`bit_width`

`countl_zero`

`countl_one`

`countr_zero`

`countr_one`

`has_single_bit`

`popcount`

`rotl`

`rotr`