complex<float>

Beschrijft een object waarin een geordende paar objecten van het type floatwordt opgeslagen, het eerste dat het werkelijke deel van een complex getal vertegenwoordigt en de tweede die het imaginaire deel vertegenwoordigt.

Syntax

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
};

Parameters

_RealVal
De waarde van het type float voor het werkelijke deel van het complexe getal dat wordt samengesteld.

_ImagVal
De waarde van het type float voor het imaginaire deel van het complexe getal dat wordt samengesteld.

complexNum
Het complexe aantal typen double of van het type long double waarvan echte en imaginaire delen worden gebruikt om een complex aantal typen float te initialiseren dat wordt samengesteld.

Return Value

Een complex aantal typen float.

Remarks

De expliciete specialisatie van het klassesjablooncomplex tot een complexe klasse van het type float verschilt alleen van de klassesjabloon in de constructors die worden gedefinieerd. De conversie van float naar double mag impliciet zijn, maar de minder veilige conversie van float naar long double is vereist explicit. Het gebruik van regels voor de inleiding met typeconversie met behulp van explicit de toewijzingssyntaxis.

Zie complex Klasse voor meer informatie over de klassjabloon complex en de bijbehorende leden.

Example

// 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.
*/

Requirements

Header: <complex>

Namespace:std

See also

complex klasse
Thread Safety in de standaardbibliotheek van C++