std::bit_expand - cppreference.com
Namespaces
Variants

    std::bit_expand

    From cppreference.com
     
    C++
     
    Utilities library
    General utilities
    Relational operators (deprecated in C++20)
    Integer comparison functions
    (C++20)(C++20)(C++20)    
    (C++20)
    Swap and type operations
    (C++20)
    (C++14)
    (C++11)
    (C++23)
    (C++11)
    (C++23)
    (C++11)
    (C++11)
    (C++17)
    Common vocabulary types
    (C++11)
    (C++17)
    (C++17)
    (C++17)
    (C++11)
    (C++11)
    (C++17)
    (C++17)
    (C++23)



     
    Bit manipulation
    (C++20)
    (C++23)
    Integral powers of 2
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    Shifting
    (C++29)
    (C++29)
    Rotating
    (C++20)
    (C++20)
    Counting
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    Permutation
    (C++29)
    (C++29)
    (C++29)
    (C++29)
    Endian
    (C++20)
     
    Defined in header <bit> 
    template< class T >
constexpr T bit_expand( T x, T mask ) noexcept;
    		(since C++29)

    Selects the least significant bits of x and places them where mask has a 1-bit. The remaining bits are 0.

    Parameters

    x - the source value to unpack
    mask - the bit-mask used for unpacking
    Type requirements
    T - must be an unsigned integer type (that is, unsigned char, unsigned short, unsigned int, unsigned long, unsigned long long, or an extended unsigned integer type) in order to participate in overload resolution.

    Return value

    x with the bit deposit through the mask mask applied.

    Notes

    The function is has the same result as the PDEP x86_64 and PDEP ARM instructions.

    Feature-test macro Value Std Feature
    __cpp_lib_bitops 202607L (C++29) Bit permutations

    Possible implementation

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

template<std::unsigned_integral T>
    requires neither<T, bool, char, char8_t, char16_t, char32_t, wchar_t>
constexpr T bit_expand(T source, T mask) noexcept
{
    T result{};
    for (T source_mask{1}, result_mask{1}; result_mask; result_mask <<= 1)
        if (result_mask & mask)
            result |= source_mask & source ? result_mask : 0,
            source_mask <<= 1;
    return result;
}

    Example

    Run this code
    #include <bit>
#include <cstdint>

static_assert(
    std::bit_expand(
        std::uint16_t{0xABCD}, // source
        std::uint16_t{0x0F0F}) // mask
    ==  std::uint16_t{0x0C0D}  // result
    and
    std::bit_expand(
        std::uint8_t{0b1010'1001}, // source
        std::uint8_t{0b0011'0011}) // mask
    ==  std::uint8_t{0b0010'0001}  // result
);

int main() {}

    See also

    (C++29)
    		 compresses bits of an operand using a mask (PEXT)
    (function template) [edit]

    External links

    1.  What is a fast fallback algorithm which emulates PDEP and PEXT in software? — SO
    2.  Reference implementation of C++26/29 bit permutation functions — github.com
    3.  ZP7: Zach's Peppy Parallel-Prefix-Popcountin' PEXT/PDEP — github.com
    4.  Henry S. Warren, Jr. Hacker's Delight, 2nd Edition, 2013, pp.150–161.