Bagikan melalui

Fungsi <bit>

Header <bit> menyertakan fungsi templat non-anggota berikut:

Fungsi non-anggota Keterangan
bit_cast Menginterpretasikan ulang representasi objek dari satu jenis ke jenis lainnya.
bit_ceil Temukan kekuatan terkecil dari dua lebih besar dari atau sama dengan nilai.
bit_floor Temukan kekuatan terbesar dua tidak lebih besar dari nilai.
bit_width Temukan jumlah bit terkecil yang diperlukan untuk mewakili nilai.
countl_zero Hitung jumlah bit berturut-turut yang diatur ke nol, mulai dari bit yang paling signifikan.
countl_one Hitung jumlah bit berturut-turut yang diatur ke satu, mulai dari bit yang paling signifikan.
countr_zero Hitung jumlah bit berturut-turut yang diatur ke nol, mulai dari bit yang paling tidak signifikan.
countr_one Hitung jumlah bit berturut-turut yang diatur ke satu, mulai dari bit yang paling tidak signifikan.
has_single_bit Periksa apakah nilai hanya memiliki satu bit yang diatur ke satu. Ini sama dengan menguji apakah nilai adalah kekuatan dua.
popcount Hitung jumlah bit yang diatur ke satu bit.
rotl Menghitung hasil rotasi kiri bitwise.
rotr Menghitung hasil rotasi kanan bitwise.

bit_cast

Salin pola bit dari objek jenis From ke objek baru jenis To.

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

Parameter

Untuk
Jenis output.

Dari
Jenis nilai yang akan dikonversi.

dari
Nilai yang akan dikonversi.

Nilai hasil

Objek jenis To.

Setiap bit dalam hasil cocok dengan bit yang sesuai di from kecuali ada bit padding dalam To, dalam hal ini bit tersebut dalam hasilnya tidak ditentukan.

Contoh

#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

Keterangan

Kode tingkat rendah sering kali perlu menginterpretasikan objek dari satu jenis sebagai jenis lain. Objek yang diinterpretasikan ulang memiliki representasi bit yang sama dengan aslinya, tetapi merupakan jenis yang berbeda.

Alih-alih menggunakan reinterpret_cast, atau memcpy(), bit_cast() adalah cara yang lebih baik untuk membuat konversi ini. Lebih baik karena:

  • bit_cast() is constexpr
  • bit_cast() mengharuskan jenis dapat disalin secara sepele dan ukuran yang sama. Ini mencegah potensi masalah yang dapat Anda temui menggunakan reinterpret_cast dan memcpy karena dapat digunakan secara tidak sengaja, dan salah, mengonversi jenis yang tidak dapat disalin secara sepele. Selain itu, memcpy() dapat digunakan untuk menyalin secara tidak sengaja antara jenis yang tidak berukuran sama. Misalnya, ganda (8 byte) menjadi int yang tidak ditandatangani (4 byte), atau sebaliknya.

Kelebihan beban ini hanya berpartisipasi dalam resolusi kelebihan beban jika:

  • sizeof(To) == sizeof(From)
  • Todan From is_trivially_copyable.

Templat fungsi ini adalah constexpr jika dan hanya jika To, From, dan jenis subobjeknya adalah:

  • Bukan tipe union atau pointer
  • Bukan penunjuk ke jenis anggota
  • Tidak memenuhi syarat volatil
  • Tidak memiliki anggota data non-statis yang merupakan jenis referensi

bit_ceil

Temukan kekuatan terkecil dari dua lebih besar dari atau sama dengan nilai. Misalnya, diberikan 3, mengembalikan 4.

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

Parameter

value
Nilai bilangan bulat yang tidak ditandatangani untuk diuji.

Nilai hasil

Kekuatan terkecil dari dua lebih besar dari atau sama dengan value.

Contoh

#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

Keterangan

Fungsi templat ini hanya berpartisipasi dalam resolusi kelebihan beban jika T merupakan jenis bilangan bulat yang tidak ditandatangani. Misalnya: unsigned int, , unsigned longunsigned short, unsigned char, dan sebagainya.

bit_floor

Temukan kekuatan terbesar dua tidak lebih besar dari nilai. Misalnya, diberikan 5, mengembalikan 4.

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

Parameter

value
Nilai bilangan bulat yang tidak ditandatangani untuk diuji.

Nilai hasil

Kekuatan terbesar dari dua yang tidak lebih besar dari value.
Jika value nol, mengembalikan nol.

Contoh

#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

Keterangan

Fungsi templat ini hanya berpartisipasi dalam resolusi kelebihan beban jika T merupakan jenis bilangan bulat yang tidak ditandatangani. Misalnya: unsigned int, , unsigned longunsigned short, unsigned char, dan sebagainya.

bit_width

Temukan jumlah bit terkecil yang diperlukan untuk mewakili nilai.

Misalnya, diberikan 5 (0b101), mengembalikan 3 karena dibutuhkan 3 bit biner untuk mengekspresikan nilai 5.

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

Parameter

value
Nilai bilangan bulat yang tidak ditandatangani untuk diuji.

Nilai hasil

Jumlah bit yang diperlukan untuk mewakili value.
Jika value nol, mengembalikan nol.

Contoh

#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

Keterangan

Fungsi templat ini hanya berpartisipasi dalam resolusi kelebihan beban jika T merupakan jenis bilangan bulat yang tidak ditandatangani. Misalnya: unsigned int, , unsigned longunsigned short, unsigned char, dan sebagainya.

countl_zero

Hitung jumlah bit berturut-turut yang diatur ke nol, mulai dari bit yang paling signifikan.

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

Parameter

value
Nilai bilangan bulat yang tidak ditandatangani untuk diuji.

Nilai hasil

Jumlah bit nol berturut-turut, mulai dari bit yang paling signifikan.
Jika value nol, jumlah bit dalam jenis value.

Contoh

#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

Keterangan

Fungsi templat ini hanya berpartisipasi dalam resolusi kelebihan beban jika T merupakan jenis bilangan bulat yang tidak ditandatangani. Misalnya: unsigned int, , unsigned longunsigned short, unsigned char, dan sebagainya.

countl_one

Hitung jumlah bit berturut-turut yang diatur ke satu, mulai dari bit yang paling signifikan.

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

Parameter

value
Nilai bilangan bulat yang tidak ditandatangani untuk diuji.

Nilai hasil

Jumlah bit berturut-turut diatur ke satu, mulai dari bit yang paling signifikan.

Contoh

#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

Keterangan

Fungsi templat ini hanya berpartisipasi dalam resolusi kelebihan beban jika T merupakan jenis bilangan bulat yang tidak ditandatangani. Misalnya: unsigned int, , unsigned longunsigned short, unsigned char, dan sebagainya.

countr_zero

Hitung jumlah bit berturut-turut yang diatur ke nol, mulai dari bit yang paling tidak signifikan.

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

Parameter

value
Nilai bilangan bulat yang tidak ditandatangani untuk diuji.

Nilai hasil

Jumlah bit nol berturut-turut, mulai dari bit yang paling tidak signifikan.
Jika value nol, jumlah bit dalam jenis value.

Contoh

#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

Keterangan

Fungsi templat ini hanya berpartisipasi dalam resolusi kelebihan beban jika T merupakan jenis bilangan bulat yang tidak ditandatangani. Misalnya: unsigned int, , unsigned longunsigned short, unsigned char, dan sebagainya.

countr_one

Hitung jumlah bit berturut-turut yang diatur ke satu, mulai dari bit yang paling tidak signifikan.

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

Parameter

value
Nilai bilangan bulat yang tidak ditandatangani untuk diuji.

Nilai hasil

Jumlah bit berturut-turut diatur ke satu, mulai dari bit yang paling tidak signifikan.

Contoh

#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

Keterangan

Fungsi templat ini hanya berpartisipasi dalam resolusi kelebihan beban jika T merupakan jenis bilangan bulat yang tidak ditandatangani. Misalnya: unsigned int, , unsigned longunsigned short, unsigned char, dan sebagainya.

has_single_bit

Periksa apakah nilai hanya memiliki satu set bit. Ini sama dengan menguji apakah nilai adalah kekuatan dua.

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

Parameter

value
Nilai bilangan bulat yang tidak ditandatangani untuk diuji.

Nilai hasil

true jika value hanya memiliki satu set bit, yang juga berarti itu value adalah kekuatan dua. Sebaliknya, false.

Contoh

#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

Keterangan

Fungsi templat ini hanya berpartisipasi dalam resolusi kelebihan beban jika T merupakan jenis bilangan bulat yang tidak ditandatangani. Misalnya: unsigned int, , unsigned longunsigned short, unsigned char, dan sebagainya.

popcount

Hitung jumlah bit yang diatur ke satu dalam nilai bilangan bulat yang tidak ditandatangani.

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

Parameter

value
Nilai bilangan bulat yang tidak ditandatangani untuk diuji.

Nilai hasil

Bit angka diatur ke satu di value.

Contoh

#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

Keterangan

Fungsi templat ini hanya berpartisipasi dalam resolusi kelebihan beban jika T merupakan jenis bilangan bulat yang tidak ditandatangani. Misalnya: unsigned int, , unsigned longunsigned short, unsigned char, dan sebagainya.

rotl

Memutar bit dari nilai bilangan bulat yang tidak ditandatangani meninggalkan jumlah waktu yang ditentukan. Bit yang "jatuh" dari bit paling kiri diputar ke bit paling kanan.

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

Parameter

value
Nilai bilangan bulat yang tidak ditandatangani untuk diputar.

s
Jumlah rotasi kiri yang akan dilakukan.

Nilai hasil

Hasil dari memutar value ke kiri, s kali.
Jika s nol, mengembalikan value.
Jika s negatif, lakukan rotr(value, -s). Bit yang 'jatuh' dari bit paling kanan diputar ke bit paling kiri.

Contoh

#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

Keterangan

Fungsi templat ini hanya berpartisipasi dalam resolusi kelebihan beban jika T merupakan jenis bilangan bulat yang tidak ditandatangani. Misalnya: unsigned int, , unsigned longunsigned short, unsigned char, dan sebagainya.

rotr

Memutar bit dari kanan berapa value kali yang ditentukan. Bit yang 'jatuh' dari bit paling kanan diputar kembali ke bit paling kiri.

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

Parameter

value
Nilai bilangan bulat yang tidak ditandatangani untuk diputar.

s
Jumlah rotasi yang tepat untuk dilakukan.

Nilai hasil

Hasil dari memutar value ke kanan, s kali.
Jika s nol, mengembalikan value.
Jika s negatif, lakukan rotl(value, -s). Bit yang 'jatuh' dari bit paling kiri diputar kembali ke bit paling kanan.

Contoh

#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

Keterangan

Fungsi templat ini hanya berpartisipasi dalam resolusi kelebihan beban jika T merupakan jenis bilangan bulat yang tidak ditandatangani. Misalnya: unsigned int, , unsigned longunsigned short, unsigned char, dan sebagainya.

Persyaratan

Header: <bit>

Namespace: std

/std:c++20 atau yang lebih baru diperlukan.

Lihat juga

<bit>