operator+,-,*,/ (std::complex)
De cppreference.com
| (1) | ||
| template< class T > std::complex<T> operator+( const std::complex<T>& lhs, const std::complex<T>& rhs ); |
(hasta C++20) | |
| template< class T > constexpr std::complex<T> operator+( const std::complex<T>& lhs, const std::complex<T>& rhs ); |
(desde C++20) | |
| (2) | ||
| template< class T > std::complex<T> operator+( const std::complex<T>& lhs, const T& rhs ); |
(hasta C++20) | |
| template< class T > constexpr std::complex<T> operator+( const std::complex<T>& lhs, const T& rhs ); |
(desde C++20) | |
| (3) | ||
| template< class T > std::complex<T> operator+( const T& lhs, const std::complex<T>& rhs ); |
(hasta C++20) | |
| template< class T > constexpr std::complex<T> operator+( const T& lhs, const std::complex<T>& rhs ); |
(desde C++20) | |
| (4) | ||
| template< class T > std::complex<T> operator-( const std::complex<T>& lhs, const std::complex<T>& rhs ); |
(hasta C++20) | |
| template< class T > constexpr std::complex<T> operator-( const std::complex<T>& lhs, const std::complex<T>& rhs ); |
(desde C++20) | |
| (5) | ||
| template< class T > std::complex<T> operator-( const std::complex<T>& lhs, const T& rhs ); |
(hasta C++20) | |
| template< class T > constexpr std::complex<T> operator-( const std::complex<T>& lhs, const T& rhs ); |
(desde C++20) | |
| (6) | ||
| template< class T > std::complex<T> operator-( const T& lhs, const std::complex<T>& rhs ); |
(hasta C++20) | |
| template< class T > constexpr std::complex<T> operator-( const T& lhs, const std::complex<T>& rhs ); |
(desde C++20) | |
| (7) | ||
| template< class T > std::complex<T> operator*( const std::complex<T>& lhs, const std::complex<T>& rhs ); |
(hasta C++20) | |
| template< class T > constexpr std::complex<T> operator*( const std::complex<T>& lhs, const std::complex<T>& rhs ); |
(desde C++20) | |
| (8) | ||
| template< class T > std::complex<T> operator*( const std::complex<T>& lhs, const T& rhs ); |
(hasta C++20) | |
| template< class T > constexpr std::complex<T> operator*( const std::complex<T>& lhs, const T& rhs ); |
(desde C++20) | |
| (9) | ||
| template< class T > std::complex<T> operator*( const T& lhs, const std::complex<T>& rhs ); |
(hasta C++20) | |
| template< class T > constexpr std::complex<T> operator*( const T& lhs, const std::complex<T>& rhs ); |
(desde C++20) | |
| (10) | ||
| template< class T > std::complex<T> operator/( const std::complex<T>& lhs, const std::complex<T>& rhs ); |
(hasta C++20) | |
| template< class T > constexpr std::complex<T> operator/( const std::complex<T>& lhs, const std::complex<T>& rhs ); |
(desde C++20) | |
| (11) | ||
| template< class T > std::complex<T> operator/( const std::complex<T>& lhs, const T& rhs ); |
(hasta C++20) | |
| template< class T > constexpr std::complex<T> operator/( const std::complex<T>& lhs, const T& rhs ); |
(desde C++20) | |
| (12) | ||
| template< class T > std::complex<T> operator/( const T& lhs, const std::complex<T>& rhs ); |
(hasta C++20) | |
| template< class T > constexpr std::complex<T> operator/( const T& lhs, const std::complex<T>& rhs ); |
(desde C++20) | |
Implementa los operadores binarios para aritmética compleja y para aritmética escalar/compleja mixta. Los argumentos escalares se tratan como números complejos con la parte real igual al argumento y la parte imaginaria igual a cero.
1-3) Devuelve la suma de sus argumentos.
4-6) Devuelve el resultado de restar
rhs de lhs.7-9) Multiplica sus argumentos.
10-12) Divide
lhs entre rhs.Contenido |
[editar] Parámetros
| lhs, rhs | - | Los argumentos: ambos números complejos o un complejo y un escalar de tipo coincidente (float, double, long double). |
[editar] Valor de retorno
1-3) std::complex<T>(lhs) += rhs
4-6) std::complex<T>(lhs) -= rhs
7-9) std::complex<T>(lhs) *= rhs
10-12) std::complex<T>(lhs) /= rhs
[editar] Notas
Debido a que la deducción de argumentos de plantilla no considera conversiones implícitas, estos operadores no se pueden usar para aritmética mixta de enteros/complejos. En todos los casos, el escalar debe tener el mismo tipo que el tipo subyacente del número complejo.
El indicador GCC -fcx-limited-range (incluido por -ffast-math) cambia el comportamiento de la multiplicación/división compleja eliminando las comprobaciones para los casos de borde de punto flotante. Esto afecta la vectorización del bucle.
[editar] Ejemplo
Ejecuta este código
#include <iostream> #include <complex> int main() { std::complex<double> c2(2, 0); std::complex<double> ci(0, 1); std::cout << ci << " + " << c2 << " = " << ci+c2 << '\n' << ci << " * " << ci << " = " << ci*ci << '\n' << ci << " + " << c2 << " / " << ci << " = " << ci+c2/ci << '\n' << 1 << " / " << ci << " = " << 1./ci << '\n'; // std::cout << 1.f/ci; // error en tiempo de compilación // std::cout << 1/ci; // error en tiempo de compilación }
Salida:
(0,1) + (2,0) = (2,1) (0,1) * (0,1) = (-1,0) (0,1) + (2,0) / (0,1) = (0,-1) 1 / (0,1) = (0,-1)
[editar] Véase también
| Asignación compuesta de dos números complejos o un complejo y un escalar. (función miembro pública) | |
| Aplica operadores unarios a números complejos. (plantilla de función) |
