std::abs(fl...f,std::fabsl(3)

std::abs(fl...f,std::fabsl(3) 🌈

okay bestie, welcome to the C++ Standard Libary manual (yes, that’s the spelling in this house 🎀). This page is the whole vibe for std::abs(float), std::fabs, std::fabsf, and std::fabsl, and we’re gonna make it make sense without losing a single detail. 💅

---

🌸 NAME 🌸

The NAME line is literally std::abs(float),std::fabs,std::fabsf,std::fabsl — then a dash — then the exact same thing again: std::abs(float),std::fabs,std::fabsf,std::fabsl. No cap, that’s the whole name section. 😭

---

🦋 Synopsis 🦋

First thing: headers. std::abs is defined in header <cmath> and also in header <cstdlib>. The std::fabs crew is defined in header <cmath>. ✨

• std::abs overloads
  • float abs( float num );
  • double abs( double num ); (until C++23)
  • long double abs( long double num );
  • constexpr /* floating-point-type */ abs( /* floating-point-type */ num ); (since C++23)
• std::fabs overloads — defined in header <cmath>
  • float fabs ( float num );
  • double fabs ( double num ); (until C++23)
  • long double fabs ( long double num ); (1)
  • constexpr /* floating-point-type */ fabs ( /* floating-point-type */ num ); (since C++23)
  • float fabsf( float num ); (2) (3) (since C++11) (constexpr since C++23)
  • long double fabsl( long double num ); (4) (since C++11) (constexpr since C++23)
• Additional overloads (since C++11)
  • Defined in header <cmath>
  • template< class Integer > (since C++11)
  • double fabs ( Integer num ); (A) (constexpr since C++23)

1-4) Computes the absolute value of the floating-point value num.

The library provides overloads of std::abs and std::fabs for all cv-unqualified floating-point types as the type of the parameter num. (since C++23)

A) Additional overloads are provided for all integer types, which are treated as double. (since C++11)

For integral arguments, the integral overloads of std::abs are likely better matches. If std::abs is called with an unsigned integral argument that cannot be converted to int by integral promotion, the program is ill-formed. That’s a hard “compiler says nope” situation, bestie — not a vibe. 💀

---

🍓 Parameters 🍓

• num — floating-point or integer value.

---

💖 Return value 💖

If successful, returns the absolute value of arg (|arg|). The value returned is exact and does not depend on any rounding modes. 🫶

---

💀 Error handling 💀

This function is not subject to any of the error conditions specified in math_errhandling.

If the implementation supports IEEE floating-point arithmetic (IEC 60559), then:

• If the argument is ±0, +0 is returned.
• If the argument is ±∞, +∞ is returned.
• If the argument is NaN, NaN is returned.

---

✨ Notes ✨

The additional overloads are not required to be provided exactly as (A). They only need to be sufficient to ensure that for their argument num of integer type, std::fabs(num) has the same effect as std::fabs(static_cast<double>(num)). 🌸

---

🧚 Example 🧚

// Run this code

#include <cmath>
#include <iostream>

int main()
{
    std::cout << "abs(+3.0) = " << std::abs(+3.0) << '\n'
              << "abs(-3.0) = " << std::abs(-3.0) << '\n';

    // special values
    std::cout << "abs(-0.0) = " << std::abs(-0.0) << '\n'
              << "abs(-Inf) = " << std::abs(-INFINITY) << '\n'
              << "abs(-NaN) = " << std::abs(-NAN) << '\n';
}

---

🌈 Possible output 🌈

abs(+3.0) = 3
abs(-3.0) = 3
abs(-0.0) = 0
abs(-Inf) = inf
abs(-NaN) = nan

---

🎀 Defect reports 🎀

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

• LWG 2192 — applied to C++98
  • Behavior as published: overloads of std::abs were inconsistently declared in two headers.
  • Correct behavior: declared these overloads in both headers.
• LWG 2735 — applied to C++11
  • Behavior as published: returning double was erroneously required.
  • Correct behavior: removed the requirement.

---

👑 See also 👑

• abs(int) — the abs(int) entry, listed here with no extra description attached.
• labs — computes absolute value of an integral value (\(\small{|x|}\)|x|) (function).
• llabs — (function) (C++11).
• copysign, copysignf, copysignl — copies the sign of a floating point value (function); these carry (C++11) markers.
• signbit — checks if the given number is negative (function) (C++11).
• abs(std::complex) — returns the magnitude of a complex number (function template).
• abs(std::valarray) — applies the function abs to each element of valarray (function template).
• C documentation for fabs — listed in SEE ALSO.

---

source: http://cppreference.com · version/date: 2024.06.10 · page: std::abs(fl...f,std::fabsl(3) 💖✨🎀