std::complex::complex

 

C++

Поддержка компилятором

Автономные и размещённые реализации

Язык

Стандартная библиотека

Заголовки стандартной библиотеки

Требования к именованию

Макросы тестирования функциональности (C++20)

Поддержка языка

Библиотека концептов (C++20)

Библиотека метапрограммирования (C++11)

Библиотека диагностики

Библиотека общих утилит

Библиотека строк

Библиотека контейнеров

Библиотека итераторов

Библиотека диапазонов (C++20)

Библиотека алгоритмов

Библиотека численных данных

Библиотека ввода/вывода

Библиотека локализаций

Регулярные выражения (C++11)

Атомарные операции (C++11)

Библиотека поддержки конкуренции (C++11)

Библиотека файловой системы (C++17)

Технические спецификации

Указатель символов

Внешние библиотеки

 

Библиотека числовых данных

Общие математические функции

Специальные математические функции (C++17)

Математические константы (C++20)

Среда с плавающей точкой (C++11)

Комплексные числа

Числовые массивы

Генерация псевдослучайных чисел

Рациональная арифметика времени компиляции (C++11)

Факторные операции

gcd (C++17)

lcm (C++17)

Интерполяции

midpoint (C++20)

lerp (C++20)

Общие числовые операции

iota (C++11)

ranges::iota (C++23)

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_cast (C++20)

byteswap (C++23)

has_single_bit (C++20)

bit_ceil (C++20)

bit_floor (C++20)

bit_width (C++20)

rotl (C++20)

rotr (C++20)

countl_zero (C++20)

countl_one (C++20)

countr_zero (C++20)

countr_one (C++20)

popcount (C++20)

endian (C++20)

 

std::complex

Функции-элементы
complex::complex
complex::operator=
complex::real
complex::imag
complex::operator+=complex::operator-=complex::operator*=complex::operator/=
Функции, не являющиеся элементами
operator+operator- operator+operator-operator*operator/ operator==operator!= (до C++20)   operator<<operator>>	real imag abs arg norm conj proj (C++11) polar operator""ioperator""ifoperator""il (C++14)(C++14)(C++14)
Экспоненциальные функции
exp
log
log10
Степенные функции
pow
sqrt
Тригонометрические функции
sin cos tan	asin (C++11) acos (C++11) atan (C++11)
Гиперболические функции
sinh cosh tanh	asinh (C++11) acosh (C++11) atanh (C++11)

 

<tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody>

Основной шаблон (std::complex<T>)
	(1)
complex( const T& re = T(), const T& im = T() );			(до C++14)
constexpr complex( const T& re = T(), const T& im = T() );			(начиная с C++14)
		(2)
complex( const complex& other );				(до C++14)
constexpr complex( const complex& other );				(начиная с C++14) (до C++23)
constexpr complex( const complex& other ) = default;				(начиная с C++23)
			(3)
template< class X > complex( const complex<X>& other );					(до C++14)
template< class X > constexpr complex( const complex<X>& other );					(начиная с C++14) (до C++23)
template< class X > explicit(/* смотрите ниже */) constexpr complex( const complex<X>& other );					(начиная с C++23)
Явные специализации для std::complex<float> (до C++23)
				(1)
complex( float re = 0.0f, float im = 0.0f );						(до C++11)
constexpr complex( float re = 0.0f, float im = 0.0f );						(начиная с C++11)
constexpr complex( const complex<float>& other ) = default;					(2)	(начиная с C++20)
					(3)
explicit complex( const complex<double>& other ); explicit complex( const complex<long double>& other );							(до C++11)
explicit constexpr complex( const complex<double>& other ); explicit constexpr complex( const complex<long double>& other );							(начиная с C++11)
Явные специализации для std::complex<double> (до C++23)
						(1)
complex( double re = 0.0, double im = 0.0 );								(до C++11)
constexpr complex( double re = 0.0, double im = 0.0 );								(начиная с C++11)
constexpr complex( const complex<double>& other ) = default;							(2)	(начиная с C++20)
							(3)
complex( const complex<float>& other ); explicit complex( const complex<long double>& other );									(до C++11)
constexpr complex( const complex<float>& other ); explicit constexpr complex( const complex<long double>& other );									(начиная с C++11)
Явные специализации для std::complex<long double> (до C++23)
								(1)
complex( long double re = 0.0L, long double im = 0.0L );										(до C++11)
constexpr complex( long double re = 0.0L, long double im = 0.0L );										(начиная с C++11)
constexpr complex( const complex<long double>& other ) = default;									(2)	(начиная с C++20)
									(3)
complex( const complex<float>& other ); complex( const complex<double>& other );											(до C++11)
constexpr complex( const complex<float>& other ); constexpr complex( const complex<double>& other );											(начиная с C++11)

Создает объект std::complex. Явные специализации для (std::complex<float>, std::complex<double> иstd::complex<long double>) имеют объявления конструкторов отдельные от основного шаблона (до C++23)

1) Создает комплексное число по вещественной части re и мнимой части im.

2) Конструктор копирования. Создает объект с копией содержимого other. Конструкторы копирования неявно объявляются в явных специализациях.. (до C++20)

3) Конструктор преобразования. Создает объект из комплексного числа другого типа.

Основной шаблон предоставляет конвертирующий шаблон конструктора, в то время как каждая стандартная явная специализация предоставляет два нешаблонных конструктора для двух других стандартных явных специализаций. Нешаблонные конструкторы являются преобразующими конструкторами (т.е. неявными) тогда и только тогда, когда преобразования действительной и мнимой частей не являются сужающими.	(до C++23)
Для основного шаблона выражение внутри explicit оценивается в false тогда и только тогда, когда ранг преобразования с плавающей точкой T больше или равен рангу преобразования с плавающей точкой X.	(начиная с C++23)

Параметры

re	—	вещественная часть
im	—	мнимая часть
other	—	ругое комплексное число для использования в качестве исходного

Примечание

Начиная с C++23, конструктор копирования долже тривиальным, чтобы удовлетворять требованию TriviallyCopyable, но реализации обычно делают его тривиальным во всех режимах.

Смотрите также

operator=	присваивает содержимое (public функция-элемент)
operator""ifoperator""ioperator""il (C++14)	литерал std::complex, представляющий чисто мнимое число (функция)
Документация C по CMPLX