std::real(std::complex)(3)

💖 NAME 💖

okay bestie, this is the manual page for std::real(std::complex)(3) from the C++ Standard Libary — yes, that manual name is staying exactly like that, typo and all 💅✨

std::real(std::complex) — literally std::real(std::complex), no notes, we move.

✨ Synopsis ✨

okay so here's the whole overload saga, bestie — don't let the line wraps scare you, every single (until C++14), (since C++14), (since C++11), (1), (A), (B), (until C++23), and (since C++23) is staying 🫶

Defined in header <complex>
template< class T >
T real( const std::complex<T>& z           (until C++14)
);
template< class T >
constexpr T real( const                    (since C++14)
std::complex<T>& z );
Additional overloads (since C++11)
Defined in header <complex>
float       real( float f );

double      real( double f );                            (until
C++14)

long double real( long double f );
constexpr float       real( float
f );                               (1)

constexpr double      real( double                       (since
C++14)
f );                                                     (until
C++23)
                                           (A)
constexpr long double real( long
double f );
template< class FloatingPoint >
constexpr FloatingPoint real(                            (since
C++23)
FloatingPoint f );
template< class Integer >
(until C++14)
double real( Integer i );
template< class Integer >                  (B)
constexpr double real( Integer i
(since C++14)
);

so like, 1) gives you the real part of the complex number z, which is literally z.real(). slay.

and A,B)? those extra overloads are provided for all integer and floating-point types, and they're treated as complex numbers with zero imaginary part (since C++11). iconic behavior fr fr 💅

🌸 Parameters 🌸

• z — complex value
• f — floating-point value
• i — integer value

🎀 Return value 🎀

• 1) The real part of z.
• A) f.
• B) static_cast<double>(i).

🦋 Notes 🦋

the additional overloads are not required to be provided exactly as (A,B). they only need to be sufficient to ensure that for their argument num:

• If num has a standard (until C++23) floating-point type T, then std::real(num) has the same effect as std::real(std::complex<T>(num)).
• Otherwise, if num has an integer type, then std::real(num) has the same effect as std::real(std::complex<double>(num)).

no cap, that's the whole vibe check on the overload rules 🧚✨

💜 See also 💜

• real — accesses the real part of the complex number (public member function)
• imag — returns the imaginary part (function template)
• C documentation for creal

k bye bestie, this page comes from http://cppreference.com, dated 2024.06.10, and its manual title is std::real(std::complex)(3) 🫶💖