std::complex::imag

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación (C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos (C++17)

Biblioteca de apoyo de concurrencia (C++11)

Biblioteca de apoyo de ejecución (C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca numérica

Funciones matemáticas comunes
Funciones matemáticas especiales (C++17)
Constantes matemáticas (C++20)
Algoritmos básicos de álgebra lineal (C++26)
Entorno de punto flotante (C++11)
Números complejos
Arrays numéricos
Generación de números pseudoaleatorios
Operaciones de factores
gcd (C++17)
lcm (C++17)
Interpolaciones
midpoint (C++20)
lerp (C++20)
Saturación aritmética
add_sat (C++26) sub_sat (C++26) saturate_cast (C++26)	mul_sat (C++26) div_sat (C++26)
Operaciones numéricas genéricas
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)
Operaciones de bits
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

Funciones miembro
complex::complex
complex::operator=
complex::real
complex::imag
complex::operator+=complex::operator-=complex::operator*=complex::operator/=
Funciones no miembro
operator+operator- operator+operator-operator*operator/ operator==operator!= (hasta C++20) operator<<operator>>	real imag abs arg norm conj proj (C++11) polar operator""ioperator""ifoperator""il (C++14)(C++14)(C++14)
Funciones exponenciales
exp
log
log10
Funciones de potencias
pow
sqrt
Funciones trigonométricas
sin cos tan	asin (C++11) acos (C++11) atan (C++11)
Funciones hiperbólicas
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> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody>

Plantilla primaria complex<T>
	(1)
T imag() const;			(hasta C++14)
constexpr T imag() const;			(desde C++14)
		(2)
void imag( T value );				(hasta C++20)
constexpr void imag( T value );				(desde C++20)
Especialización complex<float>
			(1)
float imag() const;					(hasta C++11)
constexpr float imag() const;					(desde C++11)
				(2)
void imag( float value );						(hasta C++20)
constexpr void imag( float value );						(desde C++20)
Especialización complex<double>
					(1)
double imag() const;							(hasta C++11)
constexpr double imag() const;							(desde C++11)
						(2)
void imag( double value );								(hasta C++20)
constexpr void imag( double value );								(desde C++20)
Especialización complex<long double>
							(1)
long double imag() const;									(hasta C++11)
constexpr long double imag() const;									(desde C++11)
								(2)
void imag( long double value );										(hasta C++20)
constexpr void imag( long double value );										(desde C++20)

See More

Accede a la parte imaginaria del número complejo.

1) Devuelve la parte imaginaria.

2) Establece la imaginaria real en value.

Parámetros

value

-

El valor en el que establecer la parte imaginaria.

Valor de retorno

1) La parte imaginaria *this.

2) (Ninguno)

Notas

En C++11, la sobrecarga (1) en las especializaciones de complex solía especificarse sin el calificador const. Sin embargo, en C++11, un especificador constexpr usado en una función miembro no estática implica const y, por lo tanto, el comportamiento es como si const estuviera especificado.

Véase también

imag	Devuelve el componente imaginario. (plantilla de función)
real	Accede a la parte real del número complejo. (función miembro pública)