Namespaces
Variants

std::complex<T>:: complex

From cppreference.net
C++
Numerics library
std::complex
Modèle primaire ( std:: complex < T > )
(1)
complex ( const T & re = T ( ) , const T & im = T ( ) ) ;
(jusqu'à C++14)
constexpr complex ( const T & re = T ( ) , const T & im = T ( ) ) ;
(depuis C++14)
(2)
complex ( const complex & other ) ;
(jusqu'en C++14)
constexpr complex ( const complex & other ) ;
(depuis C++14)
(jusqu'en C++23)
constexpr complex ( const complex & other ) = default ;
(depuis C++23)
(3)
template < class X >
complex ( const complex < X > & other ) ;
(jusqu'à C++14)
template < class X >
constexpr complex ( const complex < X > & other ) ;
(depuis C++14)
(jusqu'à C++23)
template < class X >
constexpr explicit ( /* voir ci-dessous */ ) complex ( const complex < X > & other ) ;
(depuis C++23)
Spécialisation explicite standard std:: complex < float > (jusqu'à C++23)
(1)
complex ( float re = 0.0f , float im = 0.0f ) ;
(jusqu'à C++11)
constexpr complex ( float re = 0.0f , float im = 0.0f ) ;
(depuis C++11)
constexpr complex ( const complex < float > & other ) = default ;
(2) (depuis C++20)
(3)
explicit complex ( const complex < double > & other ) ;
explicit complex ( const complex < long double > & other ) ;
(jusqu'à C++11)
constexpr explicit complex ( const complex < double > & other ) ;
constexpr explicit complex ( const complex < long double > & other ) ;
(depuis C++11)
Spécialisation explicite standard std:: complex < double > (jusqu'à C++23)
(1)
complex ( double re = 0.0 , double im = 0.0 ) ;
(jusqu'à C++11)
constexpr complex ( double re = 0.0 , double im = 0.0 ) ;
(depuis C++11)
constexpr complex ( const complex < double > & other ) = default ;
(2) (depuis C++20)
(3)
complex ( const complex < float > & other ) ;
explicit complex ( const complex < long double > & other ) ;
(jusqu'à C++11)
constexpr complex ( const complex < float > & other ) ;
constexpr explicit complex ( const complex < long double > & other ) ;
(depuis C++11)
Spécialisation explicite standard std:: complex < long double > (jusqu'à C++23)
(1)
complex ( long double re = 0.0L, long double im = 0.0L ) ;
(jusqu'à C++11)
constexpr complex ( long double re = 0.0L, long double im = 0.0L ) ;
(depuis C++11)
constexpr complex ( const complex < long double > & other ) = default ;
(2) (depuis C++20)
(3)
complex ( const complex < float > & other ) ;
complex ( const complex < double > & other ) ;
(jusqu'à C++11)
constexpr complex ( const complex < float > & other ) ;
constexpr complex ( const complex < double > & other ) ;
(depuis C++11)

Construit l'objet std:: complex . Les spécialisations explicites standards ( std:: complex < float > , std:: complex < double > et std:: complex < long double > ) ont des déclarations de constructeur différentes du modèle principal. (jusqu'à C++23)

1) Construit le nombre complexe à partir de la partie réelle re et de la partie imaginaire im .
2) Constructeur de copie. Construit l'objet avec la copie du contenu de other . Les constructeurs de copie sont implicitement déclarés dans les spécialisations explicites standard. (jusqu'à C++20)
3) Constructeur de conversion . Construit l'objet à partir d'un nombre complexe d'un type différent.

Le modèle principal fournit un modèle de constructeur de conversion, tandis que chaque spécialisation explicite standard fournit deux constructeurs non modèles pour les deux autres spécialisations explicites standard.

Les constructeurs non modèles sont des constructeurs de conversion (c'est-à-dire non explicites) si et seulement si les conversions des parties réelle et imaginaire ne sont pas restrictives.

(jusqu'à C++23)

Pour le modèle principal, l'expression à l'intérieur de explicit s'évalue à false si et seulement si le rang de conversion en virgule flottante de T est supérieur ou égal au rang de conversion en virgule flottante de X .

(depuis C++23)

Paramètres

re - la partie réelle
im - la partie imaginaire
other - un autre nombre complexe à utiliser comme source

Notes

Depuis C++23, le constructeur de copie doit être trivial pour satisfaire l'exigence TriviallyCopyable , mais les implémentations le rendent généralement trivial dans tous les modes.

Voir aussi

assigne le contenu
(fonction membre publique)
(C++14)
un littéral std::complex représentant un nombre purement imaginaire
(fonction)
documentation C pour CMPLX