`complex<long double>`

Article
10/12/2023

Ce modèle de classe explicitement spécialisé décrit un objet qui stocke une paire ordonnée d’objets, à la fois de type long double, la première représentant la partie réelle d’un nombre complexe et la seconde représentant la partie imaginaire.

Syntaxe

template <>
class complex<long double> {
public:
    constexpr complex(
    long double _RealVal = 0,
    long double _ImagVal = 0);

complex(
    constexpr complex<long double>& complexNum);

// rest same as class template complex
};

Paramètres

_RealVal
Valeur de type long double pour la partie réelle du nombre complexe en cours de construction.

_ImagVal
Valeur de type long double pour la partie imaginaire du nombre complexe qui est construit.

complexNum
Nombre complexe de type ou de type double float dont les parties réelles et imaginaires sont utilisées pour initialiser un nombre complexe de type long double construit.

Valeur de retour

Nombre complexe de type long double.

Notes

La spécialisation explicite du modèle complex de classe à une classe complexe de type long double diffère du modèle de classe uniquement dans les constructeurs qu’il définit. La conversion de long double vers float est autorisée à être implicite, mais la conversion de double vers long double doit être explicit. L’utilisation de règles d’initiation avec conversion de type à l’aide de explicit la syntaxe d’affectation.

Pour plus d’informations sur le modèle complex de classe et ses membres, consultez la classe complexe.

Spécifiques à Microsoft : les long double types et double les types ont la même représentation, mais sont des types distincts. Pour plus d’informations, consultez types intégrés.

Exemple

// complex_comp_ld.cpp
// compile with: /EHsc
#include <complex>
#include <iostream>

int main( )
{
    using namespace std;
    double pi = 3.14159265359;

    // The first constructor specifies real & imaginary parts
    complex<long double> c1( 4.0 , 5.0 );
    cout << "Specifying initial real & imaginary parts,\n"
        << " as type float gives c1 = " << c1 << endl;

    // The second constructor initializes values of the real &
    // imaginary parts using those of complex number of type float
    complex<float> c2float( 1.0 , 3.0 );
    complex<long double> c2longdouble ( c2float );
    cout << "Implicit conversion from type float to type long double,"
        << "\n gives c2longdouble = " << c2longdouble << endl;

    // The third constructor initializes values of the real &
    // imaginary parts using those of a complex number
    // of type double
    complex<double> c3double( 3.0 , 4.0 );
    complex<long double> c3longdouble( c3double );
    cout << "Implicit conversion from type long double to type float,"
        << "\n gives c3longdouble = " << c3longdouble << endl;

    // The modulus and argument of a complex number can be recovered
    double absc3 = abs( c3longdouble );
    double argc3 = arg( c3longdouble );
    cout << "The modulus of c3 is recovered from c3 using: abs( c3 ) = "
        << absc3 << endl;
    cout << "Argument of c3 is recovered from c3 using:\n arg( c3 ) = "
        << argc3 << " radians, which is " << argc3 * 180 / pi
        << " degrees." << endl;
}

Specifying initial real & imaginary parts,
as type float gives c1 = (4,5)
Implicit conversion from type float to type long double,
gives c2longdouble = (1,3)
Implicit conversion from type long double to type float,
gives c3longdouble = (3,4)
The modulus of c3 is recovered from c3 using: abs( c3 ) = 5
Argument of c3 is recovered from c3 using:
arg( c3 ) = 0.927295 radians, which is 53.1301 degrees.

Spécifications

En-tête : <complexe>

Espace de noms : std

Voir aussi

complex, classe
Sécurité des threads dans la bibliothèque C++ Standard

Partager via