Namespaces
Variants

    std::bit_repeat

    De es.cppreference.net
     
    C++
    Soporte del compilador
    Independiente y alojado
    Lenguaje
    Biblioteca estándar
    Encabezados de la biblioteca estándar
    Requisitos nombrados
    Macros de prueba de características (C++20)
    Biblioteca de soporte del lenguaje
    Biblioteca de conceptos (C++20)
    Biblioteca de diagnóstico
    Biblioteca de gestión de memoria
    Biblioteca de metaprogramación (C++11)
    Biblioteca de utilidades generales
    Biblioteca de contenedores
    Biblioteca de iteradores
    Biblioteca de rangos (C++20)
    Biblioteca de algoritmos
    Biblioteca de cadenas
    Biblioteca de procesamiento de texto
    Biblioteca numérica
    Biblioteca de fecha y hora
    Biblioteca de entrada/salida
    Biblioteca del sistema de archivos (C++17)
    Biblioteca de soporte de concurrencia (C++11)
    Biblioteca de control de ejecución (C++26)
    Especificaciones técnicas
    Índice de símbolos
    Bibliotecas externas
     
    Biblioteca de utilidades
    Soporte del lenguaje
    Soporte de tipos (tipos básicos, RTTI)
    Macros de prueba de características de la biblioteca (C++20)
    Utilidades de programa
    Funciones variádicas
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Soporte de corrutinas (C++20)
    Soporte de contratos (C++26)
    Comparación de tres vías
    (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)

    Utilidades generales
    Operadores relacionales (obsoleto en C++20)
     
    Manipulación de bits
    (C++20)
    (C++23)
    Potencias enteras de 2
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    Desplazamiento
    (C++29)
    (C++29)
    Rotación
    (C++20)
    (C++20)
    Conteo
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    Permutación
    (C++29)
    (C++29)
    (C++29)
    (C++29)
    Endian
    (C++20)
     
    Definido en el encabezado <bit> 
    template< class T >
constexpr T bit_repeat( T x, int l );
    		(desde C++29)

    Repite el patrón de bits en x de longitud l tantas veces como quepa en el resultado (con la última repetición potencialmente truncada).

    Si l es menor o igual que 0, el comportamiento no está definido. La llamada a esta función está permitida en evaluación constante solo si el comportamiento no definido no ocurre.

    Esta sobrecarga participa en la resolución de sobrecarga solo si T es un tipo entero sin signo (es decir, unsigned char, unsigned short, unsigned int, unsigned long, unsigned long long, o un tipo entero sin signo extendido).

    Parámetros

    x - valor de tipo entero sin signo

    Valor de retorno

    El patrón de bits repetido.

    Excepciones

    No lanza nada.

    Notas

    Prueba de características macro Valor Estándar Característica
    __cpp_lib_bitops 202606L (C++29) Permutaciones de bits

    Posible implementación

    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);
}

    Ejemplo

    Ejecutar este código
    #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() {}

    Véase también

    (C++29)
    		 invierte los bits de un entero
    (plantilla de función)
    (C++29)
    		 comprime bits de un operando usando una máscara (PEXT)
    (plantilla de función)
    (C++29)
    		 expande bits de un operando usando una máscara (PDEP)
    (plantilla de función)