std::literals::complex_literals::operator""i, operator""if, operator""il

Defined in header `<complex>`
constexpr complex<double> operator""i(long double arg); constexpr complex<double> operator""i(unsigned long long arg);	(1)	(since C++14)
constexpr complex<float> operator""if(long double arg); constexpr complex<float> operator""if(unsigned long long arg);	(2)	(since C++14)
constexpr complex<long double> operator""il(long double arg); constexpr complex<long double> operator""il(unsigned long long arg);	(3)	(since C++14)

Forms a std::complex literal representing an imaginary number.

1) forms a literal std::complex<double> with the real part zero and imaginary part arg

2) forms a literal std::complex<float> with the real part zero and imaginary part arg

3) forms a literal std::complex<long double> with the real part zero and imaginary part arg

Parameters

arg

-

the value of the imaginary number

Return value

The std::complex literal with the real part zero and imaginary part arg

Notes

These operators are declared in the namespace std::literals::complex_literals, where both literals and complex_literals are inline namespaces. Access to these operators can be gained with using namespace std::literals, using namespace std::complex_literals, and using namespace std::literals::complex_literals.

Even though if is a keyword in C++, it is a ud-suffix of the literal operator of the form operator ""if and in the literal expressions such as 1if or 1.0if because it is not separated by whitespace and is not a standalone token.

Possible implementation

First version
constexpr std::complex<double> operator""i(unsigned long long d) { return std::complex<double>{0.0, static_cast<double>(d)}; } constexpr std::complex<double> operator""i(long double d) { return std::complex<double>{0.0, static_cast<double>(d)}; }
Second version
constexpr std::complex<float> operator""if(unsigned long long d) { return std::complex<float>{0.0f, static_cast<float>(d)}; } constexpr std::complex<float> operator""if(long double d) { return std::complex<float>{0.0f, static_cast<float>(d)}; }
Third version
constexpr std::complex<long double> operator""il(unsigned long long d) { return std::complex<long double>{0.0L, static_cast<long double>(d)}; } constexpr std::complex<long double> operator""il(long double d) { return std::complex<long double>{0.0L, d}; }

Example

Run this code

#include <iostream>
#include <complex>
 
int main()
{
    using namespace std::complex_literals;
    std::complex<double> c = 1.0 + 1i;
    std::cout << "abs" << c << " = " << abs(c) << '\n';
}

Output:

abs(1,1) = 1.41421

Language
Standard Library Headers
Freestanding and hosted implementations
Named requirements
Language support library
Concepts library (C++20)
Diagnostics library
Utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Input/output library
Localizations library
Regular expressions library (C++11)
Atomic operations library (C++11)
Thread support library (C++11)
Filesystem library (C++17)
Technical Specifications

Common mathematical functions
Special mathematical functions
Floating-point environment (C++11)
Complex numbers
Numeric arrays
Pseudo-random number generation
Compile-time rational arithmetic (C++11)
Numeric algorithms
gcd (C++17)
lcm (C++17)
Interpolations
midpoint (C++20)
lerp (C++20)
Generic numeric operations
iota (C++11)
accumulate
inner_product
adjacent_difference
partial_sum
reduce (C++17)
transform_reduce (C++17)
inclusive_scan (C++17)
exclusive_scan (C++17)
transform_inclusive_scan (C++17)
transform_exclusive_scan (C++17)
Bit operations
bit_cast (C++20)
ispow2 (C++20)
ceil2 (C++20)
floor2 (C++20)
log2p1 (C++20)