std:: complex

Spezialisierungen von std::complex für cv-unqualifizierte Standard (bis C++23) Gleitkommatypen sind TriviallyCopyable (seit C++23) LiteralType s zur Darstellung und Manipulation von komplexen Zahlen .

Template-Parameter

Mitgliedstypen

Memberfunktionen

Nicht-Member-Funktionen

Hilfstypen

Array-orientierter Zugriff

Für jedes Objekt z vom Typ std::complex<T> , reinterpret_cast < T ( & ) [ 2 ] > ( z ) [ 0 ] der Realteil von z und reinterpret_cast < T ( & ) [ 2 ] > ( z ) [ 1 ] der Imaginärteil von z ist.

Für jeden Zeiger auf ein Element eines Arrays von std::complex<T> namens p und jeden gültigen Array-Index i , reinterpret_cast < T * > ( p ) [ 2 * i ] der Realteil der komplexen Zahl p [ i ] , und reinterpret_cast < T * > ( p ) [ 2 * i + 1 ] der Imaginärteil der komplexen Zahl p [ i ] ist.

Die Absicht dieser Anforderung ist es, die binäre Kompatibilität zwischen den komplexen Zahlentypen der C++-Bibliothek und den komplexen Zahlentypen der C-Sprache (und Arrays davon) zu bewahren, welche eine identische Objektdarstellungsanforderung haben.

Implementierungshinweise

Um den Anforderungen des array-orientierten Zugriffs zu genügen, ist eine Implementierung gezwungen, die Real- und Imaginärteile einer std::complex Spezialisierung in separaten und benachbarten Speicherbereichen zu speichern. Mögliche Deklarationen für ihre nicht-statischen Datenelemente umfassen:

• ein Array vom Typ value_type[2] , wobei das erste Element den Realteil und das zweite Element den Imaginärteil enthält (z.B. Microsoft Visual Studio);
• ein einzelnes Element vom Typ value_type _Complex (das den entsprechenden C-Sprache komplexen Zahlentyp kapselt) (z.B. GNU libstdc++);
• zwei Elemente vom Typ value_type , mit gleichem Elementzugriff, die jeweils den Real- und Imaginärteil enthalten (z.B. LLVM libc++).

Eine Implementierung darf keine zusätzlichen nicht-statischen Datenelemente deklarieren, die Speicher belegen würden, der von den Real- und Imaginärteilen getrennt ist, und muss sicherstellen, dass die Klassentemplatespezialisierung keine Padding-Bits enthält. Die Implementierung muss auch sicherstellen, dass Optimierungen für den Array-Zugriff die Möglichkeit berücksichtigen, dass ein Zeiger auf value_type eine std::complex -Spezialisierung oder ein Array davon aliassen könnte.

Literale

Hinweise

Beispiel

#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; // imaginäre Einheit quadriert
    std::cout << "i * i = " << z1 << '\n';
    std::complex<double> z2 = std::pow(1i, 2); // imaginäre Einheit quadriert
    std::cout << "pow(i, 2) = " << z2 << '\n';
    const double PI = std::acos(-1); // oder std::numbers::pi in C++20
    std::complex<double> z3 = std::exp(1i * PI); // Eulersche Formel
    std::cout << "exp(i * pi) = " << z3 << '\n';
    std::complex<double> z4 = 1.0 + 2i, z5 = 1.0 - 2i; // Konjugierte
    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

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

Siehe auch