std::complex

template< class T >
class complex;

template<> class complex<float>;

template<> class complex<double>;

template<> class complex<long double>;

Специализации std::complex для типов с плавающей точкой без cv-квалификаторов стандартных(до C++23) являются TriviallyCopyable(начиная с C++23) литеральными типами, предназначенными для представления и обработки комплексных чисел.

Параметры шаблона

Типы-члены

Функции-члены

Функции, не являющиеся членами

Вспомогательные типы

Доступ, ориентированный на массивы

Для любого объекта z типа std::complex<T>, reinterpret_cast<T(&)[2]>(z)[0] является действительной частью z, а reinterpret_cast<T(&)[2]>(z)[1] — мнимой частью z.

Для любого указателя на элемент массива из std::complex<T> с именем p и любого допустимого индекса массива i, reinterpret_cast<T*>(p)[2 * i] является действительной частью комплексного числа p[i], а reinterpret_cast<T*>(p)[2 * i + 1] — мнимой частью комплексного числа p[i].

Это требование предназначено для сохранения двоичной совместимости между типами комплексных чисел библиотеки C++ и типами комплексных чисел языка C (и массивами этих типов), для которых требуется идентичное представление объектов.

Примечания по реализации

Для выполнения требований к доступу, ориентированному на массивы, реализация должна хранить действительную и мнимую части специализации std::complex в отдельных смежных ячейках памяти. Возможные объявления нестатических членов данных включают:

• массив типа value_type[2], в котором первый элемент содержит действительную часть, а второй — мнимую (например, Microsoft Visual Studio);
• единственный член типа value_type _Complex (инкапсулирующий соответствующий тип комплексного числа языка C) (например, GNU libstdc++);
• два члена типа value_type с одинаковым уровнем доступа к членам, содержащие соответственно действительную и мнимую части (например, LLVM libc++).

Реализация не может объявлять дополнительные нестатические члены данных, занимающие область хранения, отличную от области хранения действительной и мнимой частей, и должна гарантировать, что специализация шаблона класса не содержит битов-отступов. Реализация также должна гарантировать, что оптимизации доступа к массивам учитывают возможность того, что указатель на value_type может иметь псевдоним, указывающий на специализацию std::complex или массив таких объектов.

Литералы

Примечания

Пример

#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; // imaginary unit squared
    std::cout << "i * i = " << z1 << '\n';

    std::complex<double> z2 = std::pow(1i, 2); // imaginary unit squared
    std::cout << "pow(i, 2) = " << z2 << '\n';

    const double PI = std::acos(-1); // or std::numbers::pi in C++20
    std::complex<double> z3 = std::exp(1i * PI); // Euler's formula
    std::cout << "exp(i * pi) = " << z3 << '\n';

    std::complex<double> z4 = 1.0 + 2i, z5 = 1.0 - 2i; // conjugates
    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

Отчёты об ошибках

Следующие отчёты об ошибках, изменяющие поведение, были применены задним числом к ранее опубликованным стандартам C++.

См. также