According to Cppreference - float_round_style, there are 4 available rounding styles used in C++ floating-point arithmetics.

Name Definition
std::round_indeterminate Rounding style cannot be determined.
std::round_toward_zero Rounding toward zero.
std::round_to_nearest Rounding toward nearest representable value, i.e. round half to even. It is also known as convergent rounding.
std::round_toward_infinity Rounding toward positive infinity.
std::round_toward_neg_infinity Rounding toward negative infinity.

I’m not sure why there is no std::round_away_from_zero i.e. rounding toward ±infinity, which is what std::round does. IEEE_754 defines all 5 rounding rules.

According to Cppreference - FE_round, floating-point to integer implicit conversion and casts always round toward zero. Meanwhile, integer to floating-point casts usually round to nearest. Results of floating-point arithmetic operators in expressions executed at compile time always round to nearest. The rounding style of the library functions std::nearbyint, std::rint, std::lrint can be set, but the rounding style of std::round, std::lround, std::llround, std::ceil, std::floor, std::trunc cannot be set.

Sometimes one may see std::floor(x + 0.5) being used as a rounding function, which does rounding toward positive infinity. Meanwhile, std::ceil(x - 0.5) does rounding toward negative infinity. Also, for std::fmod(x, y) which returns x - n * y, where n is rounded toward zero. Meanwhile, for std::remainder(x, y), where n is rounded to nearest, ties to even.

By the way, NumPy does rounding to the nearest even value.

For Xilinx FPGAs, HLS ap_fixed datatype provides:

Name Definition
AP_RND Rounding toward positive infinity.
AP_RND_ZERO Rounding toward zero.
AP_RND_MIN_INF Rounding toward negative infinity.
AP_RND_INF Rounding toward ±infinity.
AP_RND_CONV Convergent rounding.
AP_TRN Truncation to negative infinity (default).
AP_TRN_ZERO Truncation to zero.

According to the UG902 manual, quantization and overflow modes that do more than the default behavior of standard hardware arithmetic (wrap and truncate) result in operators with more associated hardware. It costs logic (LUTs) to implement the more advanced modes, such as round to minus infinity or saturate symmetrically.