std:: complex

Spécialisations de std::complex pour les types standard (jusqu'en C++23) à virgule flottante non qualifiés cv sont des TriviallyCopyable (depuis C++23) LiteralType s pour représenter et manipuler les nombres complexes .

Paramètres du modèle

Types membres

Fonctions membres

Fonctions non membres

Types auxiliaires

Accès orienté tableau

Pour tout objet z de type std::complex<T> , reinterpret_cast < T ( & ) [ 2 ] > ( z ) [ 0 ] représente la partie réelle de z et reinterpret_cast < T ( & ) [ 2 ] > ( z ) [ 1 ] représente la partie imaginaire de z .

Pour tout pointeur vers un élément d'un tableau de std::complex<T> nommé p et tout index de tableau valide i , reinterpret_cast < T * > ( p ) [ 2 * i ] représente la partie réelle du nombre complexe p [ i ] , et reinterpret_cast < T * > ( p ) [ 2 * i + 1 ] représente la partie imaginaire du nombre complexe p [ i ] .

L'intention de cette exigence est de préserver la compatibilité binaire entre les types de nombres complexes de la bibliothèque C++ et les types de nombres complexes du langage C (et leurs tableaux), qui ont une exigence identique de représentation objet.

Notes d'implémentation

Afin de satisfaire les exigences d'accès orienté tableau, une implémentation est contrainte de stocker les parties réelle et imaginaire d'une std::complex spécialisation dans des emplacements mémoire séparés et adjacents. Les déclarations possibles pour ses membres de données non statiques incluent :

• un tableau de type value_type[2] , le premier élément contenant la partie réelle et le second élément contenant la partie imaginaire (par exemple Microsoft Visual Studio) ;
• un seul membre de type value_type _Complex (encapsulant le type de nombre complexe du langage C correspondant) (par exemple GNU libstdc++) ;
• deux membres de type value_type , avec le même accès membre, contenant respectivement les parties réelle et imaginaire (par exemple LLVM libc++).

Une implémentation ne peut pas déclarer de membres de données non statiques supplémentaires qui occuperaient un stockage disjoint des parties réelle et imaginaire, et doit garantir que la spécialisation du modèle de classe ne contienne aucun bit de remplissage . L'implémentation doit également garantir que les optimisations d'accès aux tableaux prennent en compte la possibilité qu'un pointeur vers value_type puisse aliéner une spécialisation de std::complex ou un tableau de celles-ci.

Littéraux

Notes

Exemple

#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; // unité imaginaire au carré
    std::cout << "i * i = " << z1 << '\n';
    std::complex<double> z2 = std::pow(1i, 2); // unité imaginaire au carré
    std::cout << "pow(i, 2) = " << z2 << '\n';
    const double PI = std::acos(-1); // ou std::numbers::pi en C++20
    std::complex<double> z3 = std::exp(1i * PI); // formule d'Euler
    std::cout << "exp(i * pi) = " << z3 << '\n';
    std::complex<double> z4 = 1.0 + 2i, z5 = 1.0 - 2i; // conjugués
    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

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi