std:: complex

Especializaciones de std::complex para tipos de punto flotante estándar (hasta C++23) sin calificación cv son TriviallyCopyable (desde C++23) LiteralType s para representar y manipular números complejos .

Parámetros de plantilla

Tipos de miembros

Funciones miembro

Funciones no miembro

Tipos auxiliares

Acceso orientado a arreglos

Para cualquier objeto z de tipo std::complex<T> , reinterpret_cast < T ( & ) [ 2 ] > ( z ) [ 0 ] es la parte real de z y reinterpret_cast < T ( & ) [ 2 ] > ( z ) [ 1 ] es la parte imaginaria de z .

Para cualquier puntero a un elemento de un arreglo de std::complex<T> denominado p y cualquier índice válido del arreglo i , reinterpret_cast < T * > ( p ) [ 2 * i ] es la parte real del número complejo p [ i ] , y reinterpret_cast < T * > ( p ) [ 2 * i + 1 ] es la parte imaginaria del número complejo p [ i ] .

La intención de este requisito es preservar la compatibilidad binaria entre los tipos de números complejos de la biblioteca C++ y los tipos de números complejos del lenguaje C (y sus arreglos), los cuales tienen un requisito de representación de objeto idéntico.

Notas de implementación

Para satisfacer los requisitos de acceso orientado a arreglos, una implementación está obligada a almacenar las partes real e imaginaria de una std::complex especialización en ubicaciones de memoria separadas y adyacentes. Las posibles declaraciones para sus miembros de datos no estáticos incluyen:

• un arreglo de tipo value_type[2] , con el primer elemento conteniendo la parte real y el segundo elemento conteniendo la parte imaginaria (ej. Microsoft Visual Studio);
• un único miembro de tipo value_type _Complex (encapsulando el correspondiente tipo de número complejo del lenguaje C ) (ej. GNU libstdc++);
• dos miembros de tipo value_type , con el mismo acceso a miembro, conteniendo las partes real e imaginaria respectivamente (ej. LLVM libc++).

Una implementación no puede declarar miembros de datos no estáticos adicionales que ocuparían almacenamiento disjunto de las partes real e imaginaria, y debe asegurar que la especialización de la plantilla de clase no contenga ningún bit de relleno . La implementación también debe asegurar que las optimizaciones al acceso de arrays tengan en cuenta la posibilidad de que un puntero a value_type pueda estar aliasing una especialización de std::complex o un array de los mismos.

Literales

Notas

Ejemplo

#include <cmath>
#include <complex>
#include <iomanip>
#include <iostream>
#include <ranges>
int main()
{
    using namespace std::complex_literals;
    std::cout << std::fixed << std::setprecision(1);
    std::complex<double> z1 = 1i * 1i; // unidad imaginaria al cuadrado
    std::cout << "i * i = " << z1 << '\n';
    std::complex<double> z2 = std::pow(1i, 2); // unidad imaginaria al cuadrado
    std::cout << "pow(i, 2) = " << z2 << '\n';
    const double PI = std::acos(-1); // o std::numbers::pi en C++20
    std::complex<double> z3 = std::exp(1i * PI); // fórmula de Euler
    std::cout << "exp(i * pi) = " << z3 << '\n';
    std::complex<double> z4 = 1.0 + 2i, z5 = 1.0 - 2i; // conjugados
    std::cout << "(1 + 2i) * (1 - 2i) = " << z4 * z5 << '\n';
    const auto zz = {0.0 + 1i, 2.0 + 3i, 4.0 + 5i};
#if __cpp_lib_tuple_like >= 202311L
    for (double re : zz | std::views::keys)
        std::cout << re << ' ';
    std::cout << '\n';
    for (double im : zz | std::views::values)
        std::cout << im << ' ';
    std::cout << '\n';
#else
    for (double re : zz | std::views::transform([](auto z){ return z.real(); }))
        std::cout << re << ' ';
    std::cout << '\n';
    for (double im : zz | std::views::transform([](auto z){ return z.imag(); }))
        std::cout << im << ' ';
    std::cout << '\n';
#endif
}

i * i = (-1.0,0.0)
pow(i, 2) = (-1.0,0.0)
exp(i * pi) = (-1.0,0.0)
(1 + 2i) * (1 - 2i) = (5.0,0.0)
0.0 2.0 4.0
1.0 3.0 5.0

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

Véase también