`complex` Třída

Článek
08/04/2024

Šablona třídy popisuje objekt, který ukládá dva objekty typu Type, jeden, který představuje skutečnou část komplexního čísla a jeden, který představuje imaginární část.

Syntaxe

template <class Type>
class complex

Poznámky

Objekt třídy Type:

Má veřejný výchozí konstruktor, destruktor, konstruktor kopírování a operátor přiřazení s konvenčním chováním.
Lze přiřadit celočíselné hodnoty nebo hodnoty s plovoucí desetinou čárkou nebo přetypovat na tyto hodnoty s konvenčním chováním.
Definuje aritmetické operátory a matematické funkce podle potřeby, které jsou definovány pro typy s plovoucí desetinou čárkou s konvenčním chováním.

Konkrétně neexistují žádné drobné rozdíly mezi kopírovací konstrukcí a výchozí konstrukcí následovanou přiřazením. Žádná operace s objekty třídy Type nemůže vyvolat výjimky.

Explicitní specializace šablony complex třídy existují pro tři typy s plovoucí desetinou čárkou. V této implementaci je hodnota jakéhokoli jiného typu Type typecast pro double skutečné výpočty s double výsledkem přiřazeným zpět k uloženému objektu typu Type.

Členové

Konstruktory

Název	Popis
`complex`	Vytvoří komplexní číslo se zadanými skutečnými a imaginárními částmi nebo jako kopií některého jiného komplexního čísla.

Typedefs

Název	Popis
`value_type`	Typ, který představuje datový typ, který představuje skutečné a imaginární části komplexního čísla.

Funkce

Název	Popis
`imag`	Extrahuje imaginární komponentu komplexního čísla.
`real`	Extrahuje skutečnou komponentu komplexního čísla.

Operátory

Název	Popis
`operator*=`	Vynásobí cílové komplexní číslo faktorem, což může být komplexní nebo stejný typ jako skutečné a imaginární části komplexního čísla.
`operator+=`	Přidá číslo k cílovému komplexnímu číslu, kde přidané číslo může být složité nebo stejného typu jako skutečné a imaginární části komplexního čísla, ke kterému se přičte.
`operator-=`	Odečte číslo od cílového komplexního čísla, kde může být odečítání čísla složité nebo stejného typu jako skutečné a imaginární části komplexního čísla, ke kterému se přičte.
`operator/=`	Vydělí cílové komplexní číslo dělitelem, což může být složitý nebo stejný typ jako skutečné a imaginární části komplexního čísla.
`operator=`	Přiřadí číslo cílovému komplexnímu číslu, kde přiřazené číslo může být složité nebo stejného typu jako skutečné a imaginární části komplexního čísla, ke kterému se přiřazuje.

`complex`

Vytvoří komplexní číslo se zadanými skutečnými a imaginárními částmi nebo jako kopií některého jiného komplexního čísla.

constexpr complex(
    const T& _RealVal = 0,
    const T& _ImagVal = 0);

template <class Other>
constexpr complex(
    const complex<Other>& complexNum);

Parametry

_RealVal
Hodnota skutečné části použité k inicializaci komplexního čísla, které se sestavuje.

_ImagVal
Hodnota imaginární části použité k inicializaci komplexního čísla, které se sestavuje.

complexNum
Komplexní číslo, jehož skutečné a imaginární části se používají k inicializaci komplexního čísla, které se vytváří.

Poznámky

První konstruktor inicializuje uloženou skutečnou část do _RealVal a uloženou imaginární část na _Imagval. Druhý konstruktor inicializuje uloženou skutečnou část do complexNum.real() a uloženou imaginární část do complexNum.imag().

Pokud v této implementaci translator nepodporuje funkce členské šablony, šablona:

template <class Other>
complex(const complex<Other>& right);

se nahrazuje tímto:

complex(const complex& right);

což je konstruktor kopírování.

Příklad

// complex_complex.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<double> c1( 4.0 , 5.0 );
    cout << "Specifying initial real & imaginary parts,"
        << "c1 = " << c1 << endl;

    // The second constructor initializes values of the real &
    // imaginary parts using those of another complex number
    complex<double> c2( c1 );
    cout << "Initializing with the real and imaginary parts of c1,"
        << " c2 = " << c2 << endl;

    // Complex numbers can be initialized in polar form
    // but will be stored in Cartesian form
    complex<double> c3( polar( sqrt( (double)8 ) , pi / 4 ) );
    cout << "c3 = polar( sqrt( 8 ) , pi / 4 ) = " << c3 << endl;

    // The modulus and argument of a complex number can be recovered
    double absc3 = abs( c3 );
    double argc3 = arg( c3 );
    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;
}

`imag`

Extrahuje imaginární komponentu komplexního čísla.

T imag() const;

T imag(const T& right);

Parametry

right
Jedná se o komplexní číslo, jehož imaginární hodnota se má extrahovat.

Návratová hodnota

Imaginární část komplexního čísla.

Poznámky

U komplexního čísla a + bi je imaginární část nebo součást im (a + bi) = b.

Příklad

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

int main( )
{
    using namespace std;

    complex<double> c1( 4.0 , 3.0 );
    cout << "The complex number c1 = " << c1 << endl;

    double dr1 = c1.real();
    cout << "The real part of c1 is c1.real() = "
        << dr1 << "." << endl;

    double di1 = c1.imag();
    cout << "The imaginary part of c1 is c1.imag() = "
        << di1 << "." << endl;
}

The complex number c1 = (4,3)
The real part of c1 is c1.real() = 4.
The imaginary part of c1 is c1.imag() = 3.

`operator*=`

Vynásobí cílové komplexní číslo faktorem, což může být komplexní nebo stejný typ jako skutečné a imaginární části komplexního čísla.

template <class Other>
complex& operator*=(const complex<Other>& right);

complex<Type>& operator*=(const Type& right);

complex<Type>& operator*=(const complex<Type>& right);

Parametry

right
Jedná se o komplexní číslo nebo číslo, které je stejného typu jako parametr cílového komplexního čísla.

Návratová hodnota

Komplexní číslo, které bylo vynásobeno číslem zadaným jako parametr.

Poznámky

Operace je přetížena, aby bylo možné provádět jednoduché aritmetické operace bez převodu dat do určitého formátu.

Příklad

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

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

    // Example of the first member function
    // type complex<double> multiplied by type complex<double>
    complex<double> cl1( polar ( 3.0 , pi / 6 ) );
    complex<double> cr1( polar ( 2.0 , pi / 3 ) );
    cout << "The left-side complex number is cl1 = " << cl1 << endl;
    cout << "The right-side complex number is cr1 = " << cr1 << endl;

    complex<double> cs1 = cl1 * cr1;
    cout << "Quotient of two complex numbers is: cs1 = cl1 * cr1 = "
        << cs1 << endl;

    // This is equivalent to the following operation
    cl1 *= cr1;
    cout << "Quotient of two complex numbers is also: cl1 *= cr1 = "
        << cl1 << endl;

    double abscl1 = abs ( cl1 );
    double argcl1 = arg ( cl1 );
    cout << "The modulus of cl1 is: " << abscl1 << endl;
    cout << "The argument of cl1 is: "<< argcl1 << " radians, which is "
        << argcl1 * 180 / pi << " degrees." << endl << endl;

    // Example of the second member function
    // type complex<double> multiplied by type double
    complex<double> cl2 ( polar ( 3.0 , pi / 6 ) );
    double cr2 = 5.0;
    cout << "The left-side complex number is cl2 = " << cl2 << endl;
    cout << "The right-side complex number is cr2 = " << cr2 << endl;

    complex<double> cs2 = cl2 * cr2;
    cout << "Quotient of two complex numbers is: cs2 = cl2 * cr2 = "
        << cs2 << endl;

    // This is equivalent to the following operation
    cl2 *= cr2;
    cout << "Quotient of two complex numbers is also: cl2 *= cr2 = "
        << cl2 << endl;

    double abscl2 = abs ( cl2 );
    double argcl2 = arg ( cl2 );
    cout << "The modulus of cl2 is: " << abscl2 << endl;
    cout << "The argument of cl2 is: "<< argcl2 << " radians, which is "
        << argcl2 * 180 / pi << " degrees." << endl;
}

`operator+=`

Přidá číslo k cílovému komplexnímu číslu, kde přidané číslo může být složité nebo stejného typu jako skutečné a imaginární části komplexního čísla, ke kterému se přičte.

template <class Other>
complex<Type>& operator+=(const complex<Other>& right);

complex<Type>& operator+=(const Type& right);

complex<Type>& operator+=(const complex<Type>& right);

Parametry

right
Jedná se o komplexní číslo nebo číslo, které je stejného typu jako parametr cílového komplexního čísla.

Návratová hodnota

Komplexní číslo, které mělo číslo zadané jako přidaný parametr.

Poznámky

Operace je přetížena, aby bylo možné provádět jednoduché aritmetické operace bez převodu dat do určitého formátu.

Příklad

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

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

   // Example of the first member function
   // type complex<double> added to type complex<double>
   complex<double> cl1( 3.0 , 4.0 );
   complex<double> cr1( 2.0 , -1.0 );
   cout << "The left-side complex number is cl1 = " << cl1 << endl;
   cout << "The right-side complex number is cr1 = " << cr1 << endl;

   complex<double> cs1 = cl1 + cr1;
   cout << "The sum of the two complex numbers is: cs1 = cl1 + cr1 = "
        << cs1 << endl;

   // This is equivalent to the following operation
   cl1 += cr1;
   cout << "The complex number cr1 added to the complex number cl1 is:"
        << "\n cl1 += cr1 = " << cl1 << endl;

   double abscl1 = abs( cl1 );
   double argcl1 = arg( cl1 );
   cout << "The modulus of cl1 is: " << abscl1 << endl;
   cout << "The argument of cl1 is: "<< argcl1 << " radians, which is "
        << argcl1 * 180 / pi << " degrees." << endl << endl;

   // Example of the second member function
   // type double added to type complex<double>
   complex<double> cl2( -2 , 4 );
   double cr2 =5.0;
   cout << "The left-side complex number is cl2 = " << cl2 << endl;
   cout << "The right-side complex number is cr2 = " << cr2 << endl;

   complex<double> cs2 = cl2 + cr2;
   cout << "The sum of the two complex numbers is: cs2 = cl2 + cr2 = "
        << cs2 << endl;

   // This is equivalent to the following operation
   cl2 += cr2;
   cout << "The complex number cr2 added to the complex number cl2 is:"
        << "\n cl2 += cr2 = " << cl2 << endl;

   double abscl2 = abs( cl2 );
   double argcl2 = arg( cl2 );
   cout << "The modulus of cl2 is: " << abscl2 << endl;
   cout << "The argument of cl2 is: "<< argcl2 << " radians, which is "
        << argcl2 * 180 / pi << " degrees." << endl << endl;
}

The left-side complex number is cl1 = (3,4)
The right-side complex number is cr1 = (2,-1)
The sum of the two complex numbers is: cs1 = cl1 + cr1 = (5,3)
The complex number cr1 added to the complex number cl1 is:
cl1 += cr1 = (5,3)
The modulus of cl1 is: 5.83095
The argument of cl1 is: 0.54042 radians, which is 30.9638 degrees.

The left-side complex number is cl2 = (-2,4)
The right-side complex number is cr2 = 5
The sum of the two complex numbers is: cs2 = cl2 + cr2 = (3,4)
The complex number cr2 added to the complex number cl2 is:
cl2 += cr2 = (3,4)
The modulus of cl2 is: 5
The argument of cl2 is: 0.927295 radians, which is 53.1301 degrees.

`operator-=`

Odečte číslo od cílového komplexního čísla, kde může být odečítání čísla složité nebo stejného typu jako skutečné a imaginární části komplexního čísla, ke kterému se přičte.

template <class Other>
complex<Type>& operator-=(const complex<Other>& complexNum);

complex<Type>& operator-=(const Type& _RealPart);

complex<Type>& operator-=(const complex<Type>& complexNum);

Parametry

complexNum
Komplexní číslo, které se odečte od cílového komplexního čísla.

_RealPart
Reálné číslo, které se odečte od cílového komplexního čísla.

Návratová hodnota

Komplexní číslo, které mělo číslo zadané jako parametr odečítané od něj.

Poznámky

Operace je přetížena, aby bylo možné provádět jednoduché aritmetické operace bez převodu dat do určitého formátu.

Příklad

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

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

   // Example of the first member function
   // type complex<double> subtracted from type complex<double>
   complex<double> cl1( 3.0 , 4.0 );
   complex<double> cr1( 2.0 , -1.0 );
   cout << "The left-side complex number is cl1 = " << cl1 << endl;
   cout << "The right-side complex number is cr1 = " << cr1 << endl;

   complex<double> cs1 = cl1 - cr1;
   cout << "The difference between the two complex numbers is:"
        << "\n cs1 = cl1 - cr1 = " << cs1 << endl;

   // This is equivalent to the following operation
   cl1 -= cr1;
   cout << "Complex number cr1 subtracted from complex number cl1 is:"
        << "\n cl1 -= cr1 = " << cl1 << endl;

   double abscl1 = abs( cl1 );
   double argcl1 = arg( cl1 );
   cout << "The modulus of cl1 is: " << abscl1 << endl;
   cout << "The argument of cl1 is: "<< argcl1 << " radians, which is "
        << argcl1 * 180 / pi << " degrees." << endl << endl;

   // Example of the second member function
   // type double subtracted from type complex<double>
   complex<double> cl2( 2.0 , 4.0 );
   double cr2 = 5.0;
   cout << "The left-side complex number is cl2 = " << cl2 << endl;
   cout << "The right-side complex number is cr2 = " << cr2 << endl;

   complex<double> cs2 = cl2 - cr2;
   cout << "The difference between the two complex numbers is:"
        << "\n cs2 = cl2 - cr2 = " << cs2 << endl;

   // This is equivalent to the following operation
   cl2  -= cr2;
   cout << "Complex number cr2 subtracted from complex number cl2 is:"
        << "\n cl2 -= cr2 = " << cl2 << endl;

   double abscl2 = abs( cl2 );
   double argcl2 = arg( cl2 );
   cout << "The modulus of cl2 is: " << abscl2 << endl;
   cout << "The argument of cl2 is: "<< argcl2 << " radians, which is "
        << argcl2 * 180 / pi << " degrees." << endl << endl;
}

The left-side complex number is cl1 = (3,4)
The right-side complex number is cr1 = (2,-1)
The difference between the two complex numbers is:
cs1 = cl1 - cr1 = (1,5)
Complex number cr1 subtracted from complex number cl1 is:
cl1 -= cr1 = (1,5)
The modulus of cl1 is: 5.09902
The argument of cl1 is: 1.3734 radians, which is 78.6901 degrees.

The left-side complex number is cl2 = (2,4)
The right-side complex number is cr2 = 5
The difference between the two complex numbers is:
cs2 = cl2 - cr2 = (-3,4)
Complex number cr2 subtracted from complex number cl2 is:
cl2 -= cr2 = (-3,4)
The modulus of cl2 is: 5
The argument of cl2 is: 2.2143 radians, which is 126.87 degrees.

`operator/=`

Vydělí cílové komplexní číslo dělitelem, což může být složitý nebo stejný typ jako skutečné a imaginární části komplexního čísla.

template <class Other>
complex<Type>& operator/=(const complex<Other>& complexNum);

complex<Type>& operator/=(const Type& _RealPart);

complex<Type>& operator/=(const complex<Type>& complexNum);

Parametry

complexNum
Komplexní číslo, které se odečte od cílového komplexního čísla.

_RealPart
Reálné číslo, které se odečte od cílového komplexního čísla.

Návratová hodnota

Komplexní číslo, které bylo vyděleno číslem zadaným jako parametr.

Poznámky

Operace je přetížena, aby bylo možné provádět jednoduché aritmetické operace bez převodu dat do určitého formátu.

Příklad

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

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

   // Example of the first member function
   // type complex<double> divided by type complex<double>
   complex<double> cl1( polar (3.0 , pi / 6 ) );
   complex<double> cr1( polar (2.0 , pi / 3 ) );
   cout << "The left-side complex number is cl1 = " << cl1 << endl;
   cout << "The right-side complex number is cr1 = " << cr1 << endl;

   complex<double> cs1 = cl1 / cr1;
   cout << "The quotient of the two complex numbers is: cs1 = cl1 /cr1 = "
        << cs1 << endl;

   // This is equivalent to the following operation
   cl1 /= cr1;
   cout << "Quotient of two complex numbers is also: cl1 /= cr1 = "
        << cl1 << endl;

   double abscl1 = abs( cl1 );
   double argcl1 = arg( cl1 );
   cout << "The modulus of cl1 is: " << abscl1 << endl;
   cout << "The argument of cl1 is: "<< argcl1 << " radians, which is "
        << argcl1 * 180 / pi << " degrees." << endl << endl;

   // Example of the second member function
   // type complex<double> divided by type double
   complex<double> cl2( polar(3.0 , pi / 6 ) );
   double cr2 =5;
   cout << "The left-side complex number is cl2 = " << cl2 << endl;
   cout << "The right-side complex number is cr2 = " << cr2 << endl;

   complex<double> cs2 = cl2 / cr2;
   cout << "The quotient of the two complex numbers is: cs2 /= cl2 cr2 = "
        << cs2 << endl;

   // This is equivalent to the following operation
   cl2 /= cr2;
   cout << "Quotient of two complex numbers is also: cl2 = /cr2 = "
        << cl2 << endl;

   double abscl2 = abs( cl2 );
   double argcl2 = arg( cl2 );
   cout << "The modulus of cl2 is: " << abscl2 << endl;
   cout << "The argument of cl2 is: "<< argcl2 << " radians, which is "
        << argcl2 * 180 / pi << " degrees." << endl << endl;
}

The left-side complex number is cl1 = (2.59808,1.5)
The right-side complex number is cr1 = (1,1.73205)
The quotient of the two complex numbers is: cs1 = cl1 /cr1 = (1.29904,-0.75)
Quotient of two complex numbers is also: cl1 /= cr1 = (1.29904,-0.75)
The modulus of cl1 is: 1.5
The argument of cl1 is: -0.523599 radians, which is -30 degrees.

The left-side complex number is cl2 = (2.59808,1.5)
The right-side complex number is cr2 = 5
The quotient of the two complex numbers is: cs2 /= cl2 cr2 = (0.519615,0.3)
Quotient of two complex numbers is also: cl2 = /cr2 = (0.519615,0.3)
The modulus of cl2 is: 0.6
The argument of cl2 is: 0.523599 radians, which is 30 degrees.

`operator=`

Přiřadí číslo cílovému komplexnímu číslu, kde přiřazené číslo může být složité nebo stejného typu jako skutečné a imaginární části komplexního čísla, ke kterému se přiřazuje.

template <class Other>
complex<Type>& operator=(const complex<Other>& right);

complex<Type>& operator=(const Type& right);

Parametry

right
Jedná se o komplexní číslo nebo číslo, které je stejného typu jako parametr cílového komplexního čísla.

Návratová hodnota

Komplexní číslo, které bylo přiřazeno jako parametr.

Poznámky

Operace je přetížena, aby bylo možné provádět jednoduché aritmetické operace bez převodu dat do určitého formátu.

Příklad

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

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

   // Example of the first member function
   // type complex<double> assigned to type complex<double>
   complex<double> cl1( 3.0 , 4.0 );
   complex<double> cr1( 2.0 , -1.0 );
   cout << "The left-side complex number is cl1 = " << cl1 << endl;
   cout << "The right-side complex number is cr1 = " << cr1 << endl;

   cl1  = cr1;
   cout << "The complex number cr1 assigned to the complex number cl1 is:"
        << "\ncl1 = cr1 = " << cl1 << endl;

   // Example of the second member function
   // type double assigned to type complex<double>
   complex<double> cl2( -2 , 4 );
   double cr2 =5.0;
   cout << "The left-side complex number is cl2 = " << cl2 << endl;
   cout << "The right-side complex number is cr2 = " << cr2 << endl;

   cl2 = cr2;
   cout << "The complex number cr2 assigned to the complex number cl2 is:"
        << "\ncl2 = cr2 = " << cl2 << endl;

   cl2 = complex<double>(3.0, 4.0);
   cout << "The complex number (3, 4) assigned to the complex number cl2 is:"
        << "\ncl2 = " << cl2 << endl;
}

The left-side complex number is cl1 = (3,4)
The right-side complex number is cr1 = (2,-1)
The complex number cr1 assigned to the complex number cl1 is:
cl1 = cr1 = (2,-1)
The left-side complex number is cl2 = (-2,4)
The right-side complex number is cr2 = 5
The complex number cr2 assigned to the complex number cl2 is:
cl2 = cr2 = (5,0)
The complex number (3, 4) assigned to the complex number cl2 is:
cl2 = (3,4)

`real`

Získá nebo nastaví komponentu real komplexního čísla.

constexpr T real() const;

T real(const T& right);

Parametry

right
Jedná se o komplexní číslo, jehož real hodnota se má extrahovat.

Návratová hodnota

Část real komplexního čísla.

Poznámky

U komplexního čísla a + bireal je část nebo komponenta Re(a + bi) = a.

Příklad

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

int main( )
{
   using namespace std;

   complex<double> c1( 4.0 , 3.0 );
   cout << "The complex number c1 = " << c1 << endl;

   double dr1 = c1.real();
   cout << "The real part of c1 is c1.real() = "
        << dr1 << "." << endl;

   double di1 = c1.imag();
   cout << "The imaginary part of c1 is c1.imag() = "
        << di1 << "." << endl;
}

The complex number c1 = (4,3)
The real part of c1 is c1.real() = 4.
The imaginary part of c1 is c1.imag() = 3.

`value_type`

Typ, který představuje datový typ, který představuje skutečné a imaginární části komplexního čísla.

typedef Type value_type;

Poznámky

value_type je synonymem pro parametr komplexní Type šablony třídy.

Příklad

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

int main( )
{
    using namespace std;
    complex<double>::value_type a = 3, b = 4;

    complex<double> c1 ( a , b );
    cout << "Specifying initial real & imaginary parts"
        << "\nof type value_type: "
        << "c1 = " << c1 << "." << endl;
}

Specifying initial real & imaginary parts
of type value_type: c1 = (3,4).

Viz také

Bezpečný přístup z více vláken ve standardní knihovně C++

Sdílet prostřednictvím

complex Třída

Syntaxe

Poznámky

Členové

Konstruktory

Typedefs

Funkce

Operátory

complex

Parametry

Poznámky

Příklad

imag

Parametry

Návratová hodnota

Poznámky

Příklad

operator*=

Parametry

Návratová hodnota

Poznámky

Příklad

operator+=

Parametry

Návratová hodnota

Poznámky

Příklad

operator-=

Parametry

Návratová hodnota

Poznámky

Příklad

operator/=

Parametry

Návratová hodnota

Poznámky

Příklad

operator=

Parametry

Návratová hodnota

Poznámky

Příklad

real

Parametry

Návratová hodnota

Poznámky

Příklad

value_type

Poznámky

Příklad

Viz také

Váš názor

Další materiály

`complex` Třída

`complex`

`imag`

`operator*=`

`operator+=`

`operator-=`

`operator/=`

`operator=`

`real`

`value_type`