Partager via

fonctions<bit>

  • Article

L’en-tête <bit> inclut les fonctions de modèle non membres suivantes :

Fonctions non membres Description
bit_cast Réinterpret la représentation d’objet d’un type à un autre.
bit_ceil Recherchez la plus petite puissance de deux valeurs supérieures ou égales à une valeur.
bit_floor Recherchez la plus grande puissance de deux valeurs non supérieures à une valeur.
bit_width Recherchez le plus petit nombre de bits nécessaires pour représenter une valeur.
countl_zero Comptez le nombre de bits consécutifs définis sur zéro, en commençant par le bit le plus significatif.
countl_one Comptez le nombre de bits consécutifs définis sur un, en commençant par le bit le plus significatif.
countr_zero Comptez le nombre de bits consécutifs définis sur zéro, en commençant par le bit le moins significatif.
countr_one Comptez le nombre de bits consécutifs définis sur un, en commençant par le bit le moins significatif.
has_single_bit Vérifiez si une valeur n’a qu’un seul bit défini sur un. Il s’agit de la même chose que de tester si une valeur est une puissance de deux.
popcount Comptez le nombre de bits définis sur un.
rotl Calculez le résultat d’une rotation gauche au niveau du bit.
rotr Calculez le résultat d’une rotation droite au niveau du bit.

bit_cast

Copiez un modèle de bits d’un objet de type From vers un nouvel objet de type To.

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

Paramètres

Pour
Type de la sortie.

From
Type de la valeur à convertir.

from
Valeur à convertir.

Valeur retournée

Objet de type To.

Chaque bit du résultat correspond au bit correspondant, from sauf s’il existe des bits Tode remplissage, auquel cas ces bits dans le résultat ne sont pas spécifiés.

Exemple

#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

Notes

Le code de bas niveau doit souvent interpréter un objet d’un type comme un autre type. L’objet réinterprété a la même représentation de bits que l’original, mais il s’agit d’un type différent.

Au lieu d’utiliser reinterpret_cast, ou memcpy(), bit_cast() est un meilleur moyen d’effectuer ces conversions. C’est mieux parce que :

  • bit_cast() est constexpr
  • bit_cast() nécessite que les types soient copiables de manière triviale et de même taille. Cela empêche les problèmes potentiels que vous pouvez rencontrer à l’aide reinterpret_cast et memcpy parce qu’ils peuvent être utilisés par inadvertance, et de manière incorrecte, convertir des types non copiables trivialement. En outre, memcpy() vous pouvez utiliser pour copier par inadvertance entre les types qui ne sont pas de la même taille. Par exemple, un double (8 octets) dans un int non signé (4 octets) ou un autre chemin.

Cette surcharge participe uniquement à la résolution de surcharge si :

Ce modèle de fonction est constexpr si et uniquement si To, Fromet les types de leurs sous-objets sont :

  • Pas une union ou un type de pointeur
  • Pas de pointeur vers le type de membre
  • Non volatile-qualifié
  • N’avez aucun membre de données non statique qui est un type de référence

bit_ceil

Recherchez la plus petite puissance de deux valeurs supérieures ou égales à une valeur. Par exemple, donné 3, retourne 4.

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

Paramètres

value
Valeur entière non signée à tester.

Valeur retournée

La plus petite puissance de deux puissances supérieures ou égales à value.

Exemple

#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

Notes

Cette fonction de modèle participe uniquement à la résolution de surcharge s’il T s’agit d’un type entier non signé. Par exemple : unsigned int, , unsigned shortunsigned long, unsigned char, et ainsi de suite.

bit_floor

Recherchez la plus grande puissance de deux valeurs non supérieures à une valeur. Par exemple, donné 5, retourne 4.

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

Paramètres

value
Valeur entière non signée à tester.

Valeur retournée

La plus grande puissance de deux qui n’est pas supérieure à value.
S’il value s’agit de zéro, retourne zéro.

Exemple

#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

Notes

Cette fonction de modèle participe uniquement à la résolution de surcharge s’il T s’agit d’un type entier non signé. Par exemple : unsigned int, , unsigned shortunsigned long, unsigned char, et ainsi de suite.

bit_width

Recherchez le plus petit nombre de bits nécessaires pour représenter une valeur.

Par exemple, étant donné 5 (0b101), retourne 3, car il faut 3 bits binaires pour exprimer la valeur 5.

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

Paramètres

value
Valeur entière non signée à tester.

Valeur retournée

Nombre de bits nécessaires pour représenter value.
S’il value s’agit de zéro, retourne zéro.

Exemple

#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

Notes

Cette fonction de modèle participe uniquement à la résolution de surcharge s’il T s’agit d’un type entier non signé. Par exemple : unsigned int, , unsigned shortunsigned long, unsigned char, et ainsi de suite.

countl_zero

Comptez le nombre de bits consécutifs définis sur zéro, en commençant par le bit le plus significatif.

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

Paramètres

value
Valeur entière non signée à tester.

Valeur retournée

Nombre de bits zéro consécutifs, en commençant par le bit le plus significatif.
S’il value s’agit de zéro, nombre de bits dans le type de value.

Exemple

#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

Notes

Cette fonction de modèle participe uniquement à la résolution de surcharge s’il T s’agit d’un type entier non signé. Par exemple : unsigned int, , unsigned shortunsigned long, unsigned char, et ainsi de suite.

countl_one

Comptez le nombre de bits consécutifs définis sur un, en commençant par le bit le plus significatif.

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

Paramètres

value
Valeur entière non signée à tester.

Valeur retournée

Nombre de bits consécutifs définis sur un, en commençant par le bit le plus significatif.

Exemple

#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

Notes

Cette fonction de modèle participe uniquement à la résolution de surcharge s’il T s’agit d’un type entier non signé. Par exemple : unsigned int, , unsigned shortunsigned long, unsigned char, et ainsi de suite.

countr_zero

Comptez le nombre de bits consécutifs définis sur zéro, en commençant par le bit le moins significatif.

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

Paramètres

value
Valeur entière non signée à tester.

Valeur retournée

Nombre de bits zéro consécutifs, en commençant par le bit le moins significatif.
S’il value s’agit de zéro, nombre de bits dans le type de value.

Exemple

#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

Notes

Cette fonction de modèle participe uniquement à la résolution de surcharge s’il T s’agit d’un type entier non signé. Par exemple : unsigned int, , unsigned shortunsigned long, unsigned char, et ainsi de suite.

countr_one

Comptez le nombre de bits consécutifs définis sur un, en commençant par le bit le moins significatif.

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

Paramètres

value
Valeur entière non signée à tester.

Valeur retournée

Nombre de bits consécutifs définis sur un, en commençant par le bit le moins significatif.

Exemple

#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

Notes

Cette fonction de modèle participe uniquement à la résolution de surcharge s’il T s’agit d’un type entier non signé. Par exemple : unsigned int, , unsigned shortunsigned long, unsigned char, et ainsi de suite.

has_single_bit

Vérifiez si une valeur n’a qu’un seul bit défini. Il s’agit de la même chose que de tester si une valeur est une puissance de deux.

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

Paramètres

value
Valeur entière non signée à tester.

Valeur retournée

true s’il value n’a qu’un seul bit défini, ce qui signifie également qu’il value s’agit d’une puissance de deux. Sinon, false.

Exemple

#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

Notes

Cette fonction de modèle participe uniquement à la résolution de surcharge s’il T s’agit d’un type entier non signé. Par exemple : unsigned int, , unsigned shortunsigned long, unsigned char, et ainsi de suite.

popcount

Comptez le nombre de bits définis sur un dans une valeur entière non signée.

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

Paramètres

value
Valeur entière non signée à tester.

Valeur retournée

Nombre bits défini sur un en value.

Exemple

#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

Notes

Cette fonction de modèle participe uniquement à la résolution de surcharge s’il T s’agit d’un type entier non signé. Par exemple : unsigned int, , unsigned shortunsigned long, unsigned char, et ainsi de suite.

rotl

Fait pivoter les bits d’une valeur entière non signée à gauche du nombre spécifié de fois. Les bits qui « tombent » du bit le plus à gauche sont pivotés vers le bit le plus à droite.

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

Paramètres

value
Valeur entière non signée à faire pivoter.

s
Nombre de rotations gauches à effectuer.

Valeur retournée

Résultat de la rotation vers la value gauche, s des heures.
Si s la valeur est zéro, retourne value.
S’il s est négatif, fait rotr(value, -s). Les bits qui « tombent » du bit le plus à droite sont pivotés vers le bit le plus à gauche.

Exemple

#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

Notes

Cette fonction de modèle participe uniquement à la résolution de surcharge s’il T s’agit d’un type entier non signé. Par exemple : unsigned int, , unsigned shortunsigned long, unsigned char, et ainsi de suite.

rotr

Fait pivoter les bits de value droite le nombre de fois spécifié. Les bits qui « tombent » du bit le plus à droite sont pivotés vers le bit le plus à gauche.

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

Paramètres

value
Valeur entière non signée à faire pivoter.

s
Nombre de rotations droites à effectuer.

Valeur retournée

Résultat de la rotation value droite, s des heures.
Si s la valeur est zéro, retourne value.
S’il s est négatif, fait rotl(value, -s). Les bits qui « tombent » du bit le plus à gauche sont pivotés vers le bit le plus à droite.

Exemple

#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

Notes

Cette fonction de modèle participe uniquement à la résolution de surcharge s’il T s’agit d’un type entier non signé. Par exemple : unsigned int, , unsigned shortunsigned long, unsigned char, et ainsi de suite.

Spécifications

En-tête<bit>:

Espace de noms : std

/std:c++20 ou version ultérieure est nécessaire.

Voir aussi

<bit>