Namespaces
Variants

    std::complex<T>::complex

    De fr.cppreference.net
     
    C++
    Prise en charge du compilateur
    Autonome et hébergé
    Langage
    Bibliothèque standard
    En-têtes de la bibliothèque standard
    Exigences nommées
    Macros de test de fonctionnalités (C++20)
    Bibliothèque de support linguistique
    Bibliothèque de concepts (C++20)
    Bibliothèque de diagnostic
    Bibliothèque de gestion de la mémoire
    Bibliothèque de métaprogrammation (C++11)
    Bibliothèque d'utilitaires généraux
    Bibliothèque de conteneurs
    Bibliothèque d'itérateurs
    Bibliothèque de plages (C++20)
    Bibliothèque d'algorithmes
    Bibliothèque de chaînes
    Bibliothèque de traitement de texte
    Bibliothèque numérique
    Bibliothèque de date et d'heure
    Bibliothèque d'entrée/sortie
    Bibliothèque du système de fichiers (C++17)
    Bibliothèque de support de la concurrence (C++11)
    Bibliothèque de contrôle d'exécution (C++26)
    Spécifications techniques
    Index des symboles
    Bibliothèques externes
     
    Bibliothèque numérique
    Fonctions mathématiques communes
    Fonctions mathématiques spéciales (C++17)
    Constantes mathématiques (C++20)
    Algorithmes d'algèbre linéaire de base (C++26)
    Types de données parallèles (SIMD) (C++26)
    Environnement à virgule flottante (C++11)
    Nombres complexes
    Tableau numérique (valarray)
    Génération de nombres pseudo-aléatoires
    Manipulation de bits (C++20)
    Arithmétique saturée (C++26)
    Opérations de factor
    (C++17)
    (C++17)
    Interpolations
    (C++20)
    (C++20)
    Opérations numériques génériques
    Arithmétique entière vérifiée de style C
    (C++26)
    (C++26)
    (C++26)

     
    std::complex
     
    Modèle primaire (std::complex<T>)
    		 
    complex( const T& re = T(), const T& im = T() );
    		(1) (jusqu'à C++14) 
    constexpr complex( const T& re = T(), const T& im = T() );
    		(depuis C++14) 
    complex( const complex& other );
    		(2) (jusqu'à C++14) 
    constexpr complex( const complex& other );
    		(depuis C++14)
    (jusqu'à C++23)    		 
    constexpr complex( const complex& other ) = default;
    		(depuis C++23) 
    template< class X >
complex( const complex<X>& other );
    		(3) (jusqu'à C++14) 
    template< class X >
constexpr complex( const complex<X>& other );
    		(depuis C++14)
    (jusqu'à C++23)    		 
    template< class X >
constexpr explicit(/* see below */) complex( const complex<X>& other );
    		(depuis C++23)
    Spécialisation explicite standard std::complex<float> (jusqu'à C++23)
    		 
    complex( float re = 0.0f, float im = 0.0f );
    		(1) (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) 
    explicit complex( const complex<double>& other );
explicit complex( const complex<long double>& other );
    		(3) (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)
    		 
    complex( double re = 0.0, double im = 0.0 );
    		(1) (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) 
    complex( const complex<float>& other );
explicit complex( const complex<long double>& other );
    		(3) (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)
    		 
    complex( long double re = 0.0L, long double im = 0.0L );
    		(1) (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) 
    complex( const complex<float>& other );
complex( const complex<double>& other );
    		(3) (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 standard (std::complex<float>, std::complex<double> et std::complex<long double>) ont des déclarations de constructeur différentes du modèle primaire.(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 déclarés implicitement 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 primaire 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 rétrécissantes.

    		(jusqu'à C++23)

    Pour le modèle primaire, l'expression à l'intérieur de explicit est évaluée à 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