`complex` Klasa

Artykuł
10/12/2023

Szablon klasy opisuje obiekt, który przechowuje dwa obiekty typu Type, jeden, który reprezentuje rzeczywistą część liczby zespolonej i jeden, który reprezentuje wyimaginowaną część.

Składnia

template <class Type>
class complex

Uwagi

Obiekt klasy Type:

Ma publiczny konstruktor domyślny, destruktor, konstruktor kopiowania i operator przypisania z konwencjonalnym zachowaniem.
Można przypisać wartości całkowite lub zmiennoprzecinkowe albo rzutować typ na takie wartości przy użyciu konwencjonalnego zachowania.
Definiuje operatory arytmetyczne i funkcje matematyczne zdefiniowane zgodnie z potrzebami dla typów zmiennoprzecinkowych z konwencjonalnym zachowaniem.

W szczególności nie mogą istnieć subtelne różnice między konstrukcją kopii a domyślną konstrukcją, po której następuje przypisanie. Żadne operacje na obiektach klasy Type nie mogą zgłaszać wyjątków.

Istnieją jawne specjalizacje szablonu complex klasy dla trzech typów zmiennoprzecinkowych. W tej implementacji wartość dowolnego innego typu Type jest typecast do double dla rzeczywistych obliczeń, a double wynik przypisany z powrotem do przechowywanego obiektu typu Type.

Członkowie

Konstruktory

Nazwa/nazwisko	opis
`complex`	Tworzy liczbę zespoloną z określonymi rzeczywistymi i wyimaginowanymi częściami lub kopią innej liczby zespolonej.

Typedefs

Nazwa/nazwisko	opis
`value_type`	Typ reprezentujący typ danych używany do reprezentowania rzeczywistych i wyimaginowanych części liczby zespolonej.

Funkcje

Nazwa/nazwisko	opis
`imag`	Wyodrębnia wyimaginowany składnik liczby zespolonej.
`real`	Wyodrębnia rzeczywisty składnik liczby zespolonej.

Operatory

Nazwa/nazwisko	opis
`operator*=`	Mnoży docelową liczbę zespolona według współczynnika, który może być złożony lub jest tego samego typu, co rzeczywiste i wyimaginowane części liczby zespolonej.
`operator+=`	Dodaje liczbę do docelowej liczby zespolonej, gdzie liczba dodana może być złożona lub tego samego typu, co rzeczywiste i wyimaginowane części liczby zespolonej, do której jest dodawany.
`operator-=`	Odejmuje liczbę z docelowej liczby zespolonej, gdzie liczba odjęta może być złożona lub tego samego typu, co rzeczywiste i wyimaginowane części liczby zespolonej, do której jest dodawana.
`operator/=`	Dzieli docelową liczbę zespolona przez dzielnik, który może być złożony lub jest tego samego typu, co rzeczywiste i wyimaginowane części liczby zespolonej.
`operator=`	Przypisuje liczbę do docelowej liczby zespolonej, gdzie przypisana liczba może być złożona lub tego samego typu, co rzeczywiste i wyimaginowane części liczby zespolonej, do której jest przypisywana.

`complex`

Tworzy liczbę zespoloną z określonymi rzeczywistymi i wyimaginowanymi częściami lub kopią innej liczby zespolonej.

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

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

Parametry

_RealVal
Wartość rzeczywistej części użytej do zainicjowania tworzonej liczby zespolonej.

_ImagVal
Wartość części wyimaginowanej użytej do zainicjowania konstruowanej liczby zespolonej.

complexNum
Liczba zespolona, której rzeczywiste i wyimaginowane części są używane do inicjowania konstruowanej liczby zespolonej.

Uwagi

Pierwszy konstruktor inicjuje przechowywaną rzeczywistą część do _RealVal i przechowywaną wyimaginowaną część do _Imagval. Drugi konstruktor inicjuje przechowywaną rzeczywistą część do complexNum.real() i przechowywaną wyimaginowaną część do complexNum.imag().

W tej implementacji, jeśli translator nie obsługuje funkcji szablonu członkowskiego, szablon:

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

element jest zastępowany:

complex(const complex& right);

który jest konstruktorem kopii.

Przykład

// 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`

Wyodrębnia wyimaginowany składnik liczby zespolonej.

T imag() const;

T imag(const T& right);

Parametry

right
Liczba zespolona, której wyimaginowana wartość ma zostać wyodrębniona.

Wartość zwracana

Wyimaginowana część liczby zespolonej.

Uwagi

W przypadku liczby zespolonej + bi, wyimaginowana część lub składnik to Im(a + bi) = b.

Przykład

// 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*=`

Mnoży docelową liczbę zespolona według współczynnika, który może być złożony lub jest tego samego typu, co rzeczywiste i wyimaginowane części liczby zespolonej.

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

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

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

Parametry

right
Liczba zespolona lub liczba, która jest tego samego typu co parametr docelowej liczby zespolonej.

Wartość zwracana

Liczba zespolona, która została pomnożona przez liczbę określoną jako parametr.

Uwagi

Operacja jest przeciążona, aby można było wykonać proste operacje arytmetyczne bez konwersji danych na określony format.

Przykład

// 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+=`

Dodaje liczbę do docelowej liczby zespolonej, gdzie liczba dodana może być złożona lub tego samego typu, co rzeczywiste i wyimaginowane części liczby zespolonej, do której jest dodawany.

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
Liczba zespolona lub liczba, która jest tego samego typu co parametr docelowej liczby zespolonej.

Wartość zwracana

Liczba zespolonej z liczbą określoną jako dodany parametr.

Uwagi

Operacja jest przeciążona, aby można było wykonać proste operacje arytmetyczne bez konwersji danych na określony format.

Przykład

// 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-=`

Odejmuje liczbę z docelowej liczby zespolonej, gdzie liczba odjęta może być złożona lub tego samego typu, co rzeczywiste i wyimaginowane części liczby zespolonej, do której jest dodawana.

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
Liczba zespolona do odjęciu od docelowej liczby zespolonej.

_RealPart
Liczba rzeczywista do odjęciu od docelowej liczby zespolonej.

Wartość zwracana

Liczba zespolona, która miała liczbę określoną jako parametr odejmowany od niego.

Uwagi

Operacja jest przeciążona, aby można było wykonać proste operacje arytmetyczne bez konwersji danych na określony format.

Przykład

// 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/=`

Dzieli docelową liczbę zespolona przez dzielnik, który może być złożony lub jest tego samego typu, co rzeczywiste i wyimaginowane części liczby zespolonej.

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
Liczba zespolona do odjęciu od docelowej liczby zespolonej.

_RealPart
Liczba rzeczywista do odjęciu od docelowej liczby zespolonej.

Wartość zwracana

Liczba zespolona podzielona przez liczbę określoną jako parametr.

Uwagi

Operacja jest przeciążona, aby można było wykonać proste operacje arytmetyczne bez konwersji danych na określony format.

Przykład

// 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=`

Przypisuje liczbę do docelowej liczby zespolonej, gdzie przypisana liczba może być złożona lub tego samego typu, co rzeczywiste i wyimaginowane części liczby zespolonej, do której jest przypisywana.

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

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

Parametry

right
Liczba zespolona lub liczba, która jest tego samego typu co parametr docelowej liczby zespolonej.

Wartość zwracana

Liczba zespolona, która została przypisana jako parametr.

Uwagi

Operacja jest przeciążona, aby można było wykonać proste operacje arytmetyczne bez konwersji danych na określony format.

Przykład

// 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`

Pobiera lub ustawia real składnik liczby zespolonej.

constexpr T real() const;

T real(const T& right);

Parametry

right
Liczba zespolona, której real wartość ma zostać wyodrębniona.

Wartość zwracana

Część real liczby zespolonej.

Uwagi

W przypadku liczby zespolonej + bireal część lub składnik to Re(a + bi) = a.

Przykład

// 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 reprezentujący typ danych używany do reprezentowania rzeczywistych i wyimaginowanych części liczby zespolonej.

typedef Type value_type;

Uwagi

value_type jest synonimem parametru szablonu złożonego Type klasy.

Przykład

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

Zobacz też

Bezpieczeństwo wątku w standardowej bibliotece C++

complex Klasa

Składnia

Uwagi

Członkowie

Konstruktory

Typedefs

Funkcje

Operatory

complex

Parametry

Uwagi

Przykład

imag

Parametry

Wartość zwracana

Uwagi

Przykład

operator*=

Parametry

Wartość zwracana

Uwagi

Przykład

operator+=

Parametry

Wartość zwracana

Uwagi

Przykład

operator-=

Parametry

Wartość zwracana

Uwagi

Przykład

operator/=

Parametry

Wartość zwracana

Uwagi

Przykład

operator=

Parametry

Wartość zwracana

Uwagi

Przykład

real

Parametry

Wartość zwracana

Uwagi

Przykład

value_type

Uwagi

Przykład

Zobacz też

Opinia

Opinia

Dodatkowe zasoby

`complex` Klasa

`complex`

`imag`

`operator*=`

`operator+=`

`operator-=`

`operator/=`

`operator=`

`real`

`value_type`