Freigeben über

<bit> -Funktionen

  • Artikel

Der <bit> Header enthält die folgenden Nicht-Member-Vorlagenfunktionen:

Nicht-Member-Funktionen Beschreibung
bit_cast Interpretieren Sie die Objektdarstellung von einem Typ in einen anderen erneut.
bit_ceil Suchen Sie die kleinste Potenz von zwei größer als oder gleich einem Wert.
bit_floor Suchen Sie die größte Potenz von zwei nicht größer als ein Wert.
bit_width Suchen Sie die kleinste Anzahl von Bits, die zum Darstellen eines Werts erforderlich sind.
countl_zero Zählen Sie die Anzahl aufeinanderfolgender Bits, die auf Null festgelegt sind, beginnend mit dem wichtigsten Bit.
countl_one Zählen Sie die Anzahl aufeinanderfolgender Bits, die auf eins festgelegt sind, beginnend mit dem wichtigsten Bit.
countr_zero Zählen Sie die Anzahl aufeinanderfolgender Bits, die auf Null festgelegt sind, beginnend mit dem am wenigsten signifikanten Bit.
countr_one Zählen Sie die Anzahl aufeinanderfolgender Bits, die auf eins festgelegt sind, beginnend mit dem am wenigsten signifikanten Bit.
has_single_bit Überprüfen Sie, ob ein Wert nur ein Bit auf eins festgelegt ist. Dies entspricht dem Testen, ob ein Wert eine Potenz von zwei ist.
popcount Zählen Sie die Anzahl der Bits, die auf ein Bit festgelegt sind.
rotl Berechnen Sie das Ergebnis einer bitweisen linken Drehung.
rotr Berechnen Sie das Ergebnis einer bitweisen rechten Drehung.

bit_cast

Kopieren Sie ein Bitmuster aus einem Objekt vom Typ From in ein neues Objekt vom Typ To.

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

Parameter

To
Der Typ der Ausgabe.

From
Der Typ des zu konvertierenden Werts.

from
Der zu konvertierende Wert.

Rückgabewert

Ein Objekt des Typs To.

Jedes Bit im Ergebnis stimmt mit dem entsprechenden Bit from überein, es sei denn, es gibt Abstandsbits in To, in diesem Fall sind diese Bits im Ergebnis nicht angegeben.

Beispiel

#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

Hinweise

Code auf niedriger Ebene muss häufig ein Objekt eines Typs als einen anderen Typ interpretieren. Das neu interpretierte Objekt weist die gleiche Bitdarstellung wie das Original auf, ist jedoch ein anderer Typ.

Anstatt diese Konvertierungen zu verwenden reinterpret_castoder memcpy()zu verwenden, bit_cast() ist eine bessere Möglichkeit. Es ist besser, weil:

  • bit_cast() ist constexpr.
  • bit_cast() erfordert, dass die Typen trivial kopieren und dieselbe Größe aufweisen. Dies verhindert potenzielle Probleme, die sie verwenden reinterpret_cast können, und memcpy weil sie versehentlich verwendet werden können, und falsch, nicht trivial kopierbare Typen zu konvertieren. Außerdem könnte es verwendet werden, um versehentlich zwischen Typen zu kopieren, memcpy() die nicht die gleiche Größe aufweisen. Beispielsweise ein Doppelwert (8 Byte) in einem nicht signierten Int (4 Bytes) oder umgekehrt.

Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn:

Diese Funktionsvorlage ist constexpr wenn und nur, wenn To, Fromund die Typen ihrer Unterobjekte sind:

  • Kein Union- oder Zeigertyp
  • Kein Zeiger auf Membertyp
  • Nicht veränderlich qualifiziert
  • Kein nicht statisches Datenmemmemm vorhanden, bei dem es sich um einen Verweistyp handelt

bit_ceil

Suchen Sie die kleinste Potenz von zwei größer als oder gleich einem Wert. Gibt z. B. , gibt 3zurück 4.

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

Parameter

value
Der zu testende ganzzahlige Wert ohne Vorzeichen.

Rückgabewert

Die kleinste Leistung von zwei größer als oder gleich value.

Beispiel

#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

Hinweise

Diese Vorlagenfunktion nimmt nur an der Überladungsauflösung teil, wenn T es sich um einen nicht signierten ganzzahligen Typ handelt. Beispiel: unsigned int, , unsigned long, unsigned short, unsigned charusw.

bit_floor

Suchen Sie die größte Potenz von zwei nicht größer als ein Wert. Gibt z. B. , gibt 5zurück 4.

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

Parameter

value
Der zu testende ganzzahlige Wert ohne Vorzeichen.

Rückgabewert

Die größte Macht von zwei, die nicht größer als valueist.
Wenn value null ist, wird Null zurückgegeben.

Beispiel

#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

Hinweise

Diese Vorlagenfunktion nimmt nur an der Überladungsauflösung teil, wenn T es sich um einen nicht signierten ganzzahligen Typ handelt. Beispiel: unsigned int, , unsigned long, unsigned short, unsigned charusw.

bit_width

Suchen Sie die kleinste Anzahl von Bits, die zum Darstellen eines Werts erforderlich sind.

Gibt z. B. 5 (0b101) den Wert 3 zurück, da 3 Binäre Bits benötigt werden, um den Wert 5 auszudrücken.

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

Parameter

value
Der zu testende ganzzahlige Wert ohne Vorzeichen.

Rückgabewert

Die Anzahl der Bits, die zum Darstellen valueerforderlich sind.
Wenn value null ist, wird Null zurückgegeben.

Beispiel

#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

Hinweise

Diese Vorlagenfunktion nimmt nur an der Überladungsauflösung teil, wenn T es sich um einen nicht signierten ganzzahligen Typ handelt. Beispiel: unsigned int, , unsigned long, unsigned short, unsigned charusw.

countl_zero

Zählen Sie die Anzahl aufeinanderfolgender Bits, die auf Null festgelegt sind, beginnend mit dem wichtigsten Bit.

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

Parameter

value
Der zu testende ganzzahlige Wert ohne Vorzeichen.

Rückgabewert

Die Anzahl der aufeinanderfolgenden Nullbits, beginnend mit dem wichtigsten Bit.
Wenn value null ist, die Anzahl der Bits im Typ von value.

Beispiel

#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

Hinweise

Diese Vorlagenfunktion nimmt nur an der Überladungsauflösung teil, wenn T es sich um einen nicht signierten ganzzahligen Typ handelt. Beispiel: unsigned int, , unsigned long, unsigned short, unsigned charusw.

countl_one

Zählen Sie die Anzahl aufeinanderfolgender Bits, die auf eins festgelegt sind, beginnend mit dem wichtigsten Bit.

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

Parameter

value
Der zu testende ganzzahlige Wert ohne Vorzeichen.

Rückgabewert

Die Anzahl der aufeinanderfolgenden Bits, die auf eins festgelegt sind, beginnend mit dem wichtigsten Bit.

Beispiel

#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

Hinweise

Diese Vorlagenfunktion nimmt nur an der Überladungsauflösung teil, wenn T es sich um einen nicht signierten ganzzahligen Typ handelt. Beispiel: unsigned int, , unsigned long, unsigned short, unsigned charusw.

countr_zero

Zählen Sie die Anzahl aufeinanderfolgender Bits, die auf Null festgelegt sind, beginnend mit dem am wenigsten signifikanten Bit.

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

Parameter

value
Der zu testende ganzzahlige Wert ohne Vorzeichen.

Rückgabewert

Die Anzahl der aufeinanderfolgenden Nullbits, beginnend mit dem geringsten signifikanten Bit.
Wenn value null ist, die Anzahl der Bits im Typ von value.

Beispiel

#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

Hinweise

Diese Vorlagenfunktion nimmt nur an der Überladungsauflösung teil, wenn T es sich um einen nicht signierten ganzzahligen Typ handelt. Beispiel: unsigned int, , unsigned long, unsigned short, unsigned charusw.

countr_one

Zählen Sie die Anzahl aufeinanderfolgender Bits, die auf eins festgelegt sind, beginnend mit dem am wenigsten signifikanten Bit.

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

Parameter

value
Der zu testende ganzzahlige Wert ohne Vorzeichen.

Rückgabewert

Die Anzahl der aufeinanderfolgenden Bits, die auf eins festgelegt sind, beginnend mit dem am wenigsten signifikanten Bit.

Beispiel

#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

Hinweise

Diese Vorlagenfunktion nimmt nur an der Überladungsauflösung teil, wenn T es sich um einen nicht signierten ganzzahligen Typ handelt. Beispiel: unsigned int, , unsigned long, unsigned short, unsigned charusw.

has_single_bit

Überprüfen Sie, ob ein Wert nur ein Bit festgelegt hat. Dies entspricht dem Testen, ob ein Wert eine Potenz von zwei ist.

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

Parameter

value
Der zu testende ganzzahlige Wert ohne Vorzeichen.

Rückgabewert

true wenn value nur ein Bit festgelegt ist, bedeutet dies auch, dass es value sich um eine Leistung von zwei handelt. Andernfalls false.

Beispiel

#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

Hinweise

Diese Vorlagenfunktion nimmt nur an der Überladungsauflösung teil, wenn T es sich um einen nicht signierten ganzzahligen Typ handelt. Beispiel: unsigned int, , unsigned long, unsigned short, unsigned charusw.

popcount

Zählen Sie die Anzahl der Bits, die auf eine in einem ganzzahligen Wert ohne Vorzeichen festgelegt sind.

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

Parameter

value
Der zu testende ganzzahlige Wert ohne Vorzeichen.

Rückgabewert

Die Zahlenbits, die auf eins festgelegt sind.value

Beispiel

#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

Hinweise

Diese Vorlagenfunktion nimmt nur an der Überladungsauflösung teil, wenn T es sich um einen nicht signierten ganzzahligen Typ handelt. Beispiel: unsigned int, , unsigned long, unsigned short, unsigned charusw.

rotl

Dreht die Bits eines ganzzahligen Werts ohne Vorzeichen nach links die angegebene Anzahl von Malen. Bits, die aus dem äußerst linken Bit fallen, werden in das äußerst rechte Bit gedreht.

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

Parameter

value
Der ganzzahlige Wert ohne Vorzeichen, der gedreht werden soll.

s
Die Anzahl der auszuführenden linken Drehungen.

Rückgabewert

Das Ergebnis der Drehung value nach links, s Uhrzeiten.
Wenn s null ist, wird zurückgegeben value.
Wenn s dies negativ ist, führt dies rotr(value, -s)aus. Bits, die vom äußerst rechten Bit ausfallen, werden in das äußerst linke Bit gedreht.

Beispiel

#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

Hinweise

Diese Vorlagenfunktion nimmt nur an der Überladungsauflösung teil, wenn T es sich um einen nicht signierten ganzzahligen Typ handelt. Beispiel: unsigned int, , unsigned long, unsigned short, unsigned charusw.

rotr

Dreht die Bits nach value rechts um die angegebene Anzahl von Malen. Bits, die vom äußerst rechten Bit wegfallen, werden wieder in das äußerst linke Bit gedreht.

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

Parameter

value
Der ganzzahlige Wert ohne Vorzeichen, der gedreht werden soll.

s
Die Anzahl der auszuführenden rechten Drehungen.

Rückgabewert

Das Ergebnis der Drehung nach value rechts, s Uhrzeiten.
Wenn s null ist, wird zurückgegeben value.
Wenn s dies negativ ist, führt dies rotl(value, -s)aus. Bits, die aus dem äußerst linken Bit herausfallen, werden wieder in das äußerst rechte Bit gedreht.

Beispiel

#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

Hinweise

Diese Vorlagenfunktion nimmt nur an der Überladungsauflösung teil, wenn T es sich um einen nicht signierten ganzzahligen Typ handelt. Beispiel: unsigned int, , unsigned long, unsigned short, unsigned charusw.

Anforderungen

Header<bit>:

Namespace: std

/std:c++20 oder höher ist erforderlich.

Weitere Informationen

<bit>