std::shr

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Diagnostics library

Memory management library

Metaprogramming library (C++11)

General utilities library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Strings library

Text processing library

Numerics library

Date and time library

Input/output library

Filesystem library (C++17)

Concurrency support library (C++11)

Execution control library (C++26)

Technical specifications

Symbols index

External libraries

 

Utilities library

Language support Type support (basic types, RTTI) Library feature-test macros (C++20) Program utilities Variadic functions initializer_list (C++11) is_constant_evaluated (C++20) is_within_lifetime (C++26) source_location (C++20) Coroutine support (C++20) Contract support (C++26) Three-way comparison three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)     type_order (C++26) is_eqis_ltis_lteq (C++20)(C++20)(C++20) is_neqis_gtis_gteq (C++20)(C++20)(C++20)

General utilities Function objects Bit manipulation (C++20) bitset hash (C++11) Relational operators (deprecated in C++20) rel_ops::operator!=rel_ops::operator>      rel_ops::operator<=rel_ops::operator>= Integer comparison functions cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)     cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Swap and type operations swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Common vocabulary types pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

Bit manipulation

bit_cast (C++20)

byteswap (C++23)

Integral powers of 2

has_single_bit (C++20)

bit_ceil (C++20)

bit_floor (C++20)

bit_width (C++20)

Shifting

shl (C++29)

shr (C++29)

Rotating

rotl (C++20)

rotr (C++20)

Counting

countl_zero (C++20)

countl_one (C++20)

countr_zero (C++20)

countr_one (C++20)

popcount (C++20)

Permutation

bit_reverse (C++29)

bit_repeat (C++29)

bit_compress (C++29)

bit_expand (C++29)

Endian

endian (C++20)

 

Defined in header <bit>
template< class T, class S > constexpr T shr( T x, S s ) noexcept;		(since C++29)

Returns \(\small{\lfloor x \times 2^{-s} \rfloor}\)⌊x · 2-s
⌋ rounded towards negative infinity, and truncated to fit into T.

Parameters

x	-	value of unsigned integer type
s	-	number of positions to shift

Return value

\(\small{\lfloor x \times 2^{-s} \rfloor}\)⌊x · 2-s
⌋ truncated to the result type.

Notes

Unlike the >> operator, std::shr never has undefined behavior. Shifting takes place as if by shifting to the right by a single bit s times, or shifting to the left by a single bit -s times if s is negative, except that -s cannot overflow.

Feature-test macro	Value	Std	Feature
__cpp_lib_bitops	202606L	(C++29)	Better shifting

Possible implementation

template<class T, class S> // TODO: constraints constexpr T shr(T x, S s) noexcept { constexpr auto width = S(std::numeric_limits<std::make_unsigned_t<T>>::digits); if constexpr (std::is_signed_v<S>) { if (s < 0) return s <= -width ? T(0) : x << -s; } return s >= width ? T(x < 0 ? -1 : 0) : x >> s; }

Example

Run this code

#include <bit>
#include <concepts>
#include <cstdint>
#include <limits>

template<std::unsigned_integral T>
constexpr bool is_set(T bits, int bit_num) noexcept
{
#if (__cpp_lib_bitops >= 202606L)
    // Never undefined.
    return std::shr(bits, bit_num) & 1;
#else
    // Requires special cases to guard against overlong
    // shifts, otherwise the behavior is undefined.
    if (std::numeric_limits<T>::digits < bit_num)
        return false;
    return (bits >> bit_num) & 1;
#endif
}
static_assert( is_set(0b101U, 0));
static_assert(!is_set(0b101U, 1));
static_assert( is_set(0b101U, 2));
static_assert(!is_set(0b101U, 69)); // well formed

#if (__cpp_lib_bitops >= 202606L)
static_assert(std::shr(std::uint8_t(0b0011), -2) == 0b1100); // negative shift is OK
#endif

int main() {}

See also

shl (C++29)	shifts to the left without the possibility of undefined behavior (function template)
rotl (C++20)	computes the result of bitwise left-rotation (function template)
rotr (C++20)	computes the result of bitwise right-rotation (function template)