Namespaces
Variants

    std::bit_repeat

    De fr.cppreference.net
     
    C++
    Support du compilateur
    Autonome et hébergé
    Langage
    Bibliothèque standard
    En-têtes de la bibliothèque standard
    Exigences nommées
    Macros de test de fonctionnalités (C++20)
    Bibliothèque de support linguistique
    Bibliothèque de concepts (C++20)
    Bibliothèque de diagnostics
    Bibliothèque de gestion de la mémoire
    Bibliothèque de métaprogrammation (C++11)
    Bibliothèque d'utilitaires généraux
    Bibliothèque de conteneurs
    Bibliothèque d'itérateurs
    Bibliothèque de plages (C++20)
    Bibliothèque d'algorithmes
    Bibliothèque de chaînes
    Bibliothèque de traitement de texte
    Bibliothèque numérique
    Bibliothèque de date et heure
    Bibliothèque d'entrée/sortie
    Bibliothèque du système de fichiers (C++17)
    Bibliothèque de support de la concurrence (C++11)
    Bibliothèque de contrôle d'exécution (C++26)
    Spécifications techniques
    Index des symboles
    Bibliothèques externes
     
    Bibliothèque d'utilitaires
    Support linguistique
    Support des types (types de base, RTTI)
    Macros de test de fonctionnalités de la bibliothèque (C++20)
    Utilitaires de programme
    Fonctions variadiques
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Support des coroutines (C++20)
    Support des contrats (C++26)
    Comparaison à trois voies
    (C++20)(C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)    
    (C++20)(C++20)(C++20)    
    (C++20)(C++20)(C++20)

    Utilitaires généraux
    Opérateurs relationnels (déprécié en C++20)
     
    Manipulation de bits
    (C++20)
    (C++23)
    Puissances entières de 2
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    Décalage
    (C++29)
    (C++29)
    Rotation
    (C++20)
    (C++20)
    Comptage
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    Permutation
    (C++29)
    (C++29)
    (C++29)
    (C++29)
    Endianness
    (C++20)
     
    Défini dans l'en-tête <bit> 
    template< class T >
constexpr T bit_repeat( T x, int l );
    		(depuis C++29)

    Répète le motif de bits dans x de longueur l autant de fois qu'il tient dans le résultat (la dernière répétition étant potentiellement tronquée).

    Si l est inférieur ou égal à 0, le comportement est indéfini. L'appel à cette fonction n'est autorisé dans une évaluation constante que si le comportement indéfini ne se produit pas.

    Cette surcharge ne participe à la résolution de surcharge que si T est un type entier non signé (c'est-à-dire unsigned char, unsigned short, unsigned int, unsigned long, unsigned long long, ou un type entier non signé étendu).

    Paramètres

    x - valeur d'un type entier non signé

    Valeur de retour

    Le motif de bits répété.

    Exceptions

    Ne lance rien.

    Notes

    Macro de test de fonctionnalité macro Valeur Std Fonctionnalité
    __cpp_lib_bitops 202606L (C++29) Permutations de bits

    Implémentation possible

    template<typename T, typename ... U>
concept neither = (!std::same_as<T, U> && ...);

// This is a valid, but highly inefficient version of bit_repeat.
template<std::unsigned_integral T>
    requires neither<T, bool, char, char8_t, char16_t, char32_t, wchar_t>
constexpr T bit_repeat_naive(T x, int l) noexcept
{
    T result = 0;
    for (int i = 0; i != std::numeric_limits<T>::digits; ++i)
        result |= ((x >> (i % length)) & 1) << i;
    return result;
}

// Constant-time implementation (preferred).
template<std::unsigned_integral T>
    requires neither<T, bool, char, char8_t, char16_t, char32_t, wchar_t>
constexpr T bit_repeat(T x, int l) noexcept
{
    static constexpr auto lookup = []
    {
        std::array<T, std::numeric_limits<T>::digits> result{};
        for (std::size_t i = 1; i != result.size(); ++i)
            result[i] = bit_repeat_naive(one, l);
        return result;
    }();
    if (l >= std::numeric_limits<T>::digits)
        return x;
    T mask = (T{1} << l) - T{1};
    return lookup[l] * (mask & x);
}

    Exemple

    Exécuter ce code
    #include <bit>
#include <cstdint>

static_assert(
    std::bit_repeat(
        std::uint8_t{1}, 1) ==
        std::uint8_t{0b1111'1111} and
    std::bit_repeat(
        std::uint8_t{0b1110}, 2) ==
        std::uint8_t{0b1010'1010} and
    std::bit_repeat(
        std::uint8_t{0b101}, 3) ==
        std::uint8_t{0b1'101'101} and
    std::bit_repeat(
        std::uint16_t{0b1100}, 4) ==
        std::uint16_t{0b1100'1100'1100'1100}
);

int main() {}

    Voir aussi

    (C++29)
    		 inverse les bits d'un entier
    (modèle de fonction)
    (C++29)
    		 comprime les bits d'un opérande à l'aide d'un masque (PEXT)
    (modèle de fonction)
    (C++29)
    		 dilate les bits d'un opérande à l'aide d'un masque (PDEP)
    (modèle de fonction)