`complex<float>`

Article
08/02/2024

Décrit un objet qui stocke une paire ordonnée d'objets de type float, le premier représentant la partie réelle d'un nombre complexe et le deuxième représentant la partie imaginaire.

Syntaxe

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

constexpr complex(
    const complex<float>& complexNum);

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

constexpr complex(
    const complex<long double>& complexNum);
// rest same as class template complex
};

Paramètres

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

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

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

Valeur de retour

Nombre complexe de type float.

Notes

La spécialisation explicite du modèle de classe complexe à une classe de type float complexe diffère du modèle de classe uniquement dans les constructeurs qu’il définit. La conversion de float vers double est autorisée à être implicite, mais la conversion la moins sûre de float vers long double est nécessaire.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 complexde classe, consultez la classe complexe. Pour obtenir la liste des membres du modèle complexde classe, consultez .

Exemple

// complex_comp_flt.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 <float> 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 double
   complex <double> c2double ( 1.0 , 3.0 );
   complex <float> c2float ( c2double );
   cout << "Implicit conversion from type double to type float,"
        << endl << "gives c2float = " << c2float << endl;

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

   // The modulus and argument of a complex number can be recovered
   double absc3 = abs ( c3float);
   double argc3 = arg ( c3float);
   cout << "The modulus of c3 is recovered from c3 using: abs ( c3 ) = "
        << absc3 << endl;
   cout << "Argument of c3 is recovered from c3 using:"
        << endl << "arg ( c3 ) = "
        << argc3 << " radians, which is " << argc3 * 180 / pi
        << " degrees." << endl;
}
/* Output:
Specifying initial real & imaginary parts,
as type float gives c1 = (4,5)
Implicit conversion from type double to type float,
gives c2float = (1,3)
Explicit conversion from type long double to type float,
gives c3float = (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