`complex` Kelas

2023-06-16

Templat kelas menjelaskan objek yang menyimpan dua objek jenis Type, satu yang mewakili bagian nyata dari bilangan kompleks dan objek yang mewakili bagian imajiner.

Sintaks

template <class Type>
class complex

Keterangan

Objek kelas Type:

Memiliki konstruktor default publik, destruktor, konstruktor salinan, dan operator penugasan dengan perilaku konvensional.
Dapat diberi nilai bilangan bulat atau floating-point, atau mengetikkan ke nilai tersebut dengan perilaku konvensional.
Menentukan operator aritmatika dan fungsi matematika, sesuai kebutuhan, yang didefinisikan untuk jenis floating-point dengan perilaku konvensional.

Secara khusus, tidak ada perbedaan halus yang mungkin ada antara konstruksi salinan dan konstruksi default diikuti oleh penugasan. Tidak ada operasi pada objek kelas Type yang dapat melemparkan pengecualian.

Spesialisasi eksplisit templat complex kelas ada untuk tiga jenis floating-point. Dalam implementasi ini, nilai dari jenis Type lain adalah typecast untuk double perhitungan aktual, dengan double hasil yang ditetapkan kembali ke objek tersimpan jenis Type.

Anggota

Konstruktor

Nama	Deskripsi
`complex`	Membuat bilangan kompleks dengan bagian nyata dan imajiner tertentu atau sebagai salinan dari beberapa bilangan kompleks lainnya.

Typedefs

Nama	Deskripsi
`value_type`	Jenis yang mewakili jenis data yang digunakan untuk mewakili bagian nyata dan imajiner dari bilangan kompleks.

Fungsi

Nama	Deskripsi
`imag`	Mengekstrak komponen imajiner dari bilangan kompleks.
`real`	Mengekstrak komponen riil dari bilangan kompleks.

Operator

Nama	Deskripsi
`operator*=`	Mengalikan bilangan kompleks target dengan faktor, yang mungkin kompleks atau merupakan jenis yang sama seperti bagian nyata dan imajiner dari bilangan kompleks.
`operator+=`	Menambahkan angka ke bilangan kompleks target, di mana angka yang ditambahkan mungkin kompleks atau dengan jenis yang sama seperti bagian nyata dan imajiner dari bilangan kompleks yang ditambahkannya.
`operator-=`	Mengurangi angka dari bilangan kompleks target, di mana angka yang dikurangi mungkin kompleks atau dengan jenis yang sama seperti bagian nyata dan imajiner dari bilangan kompleks yang ditambahkannya.
`operator/=`	Membagi bilangan kompleks target dengan pembagi, yang mungkin kompleks atau merupakan jenis yang sama seperti bagian nyata dan imajiner dari bilangan kompleks.
`operator=`	Menetapkan angka ke bilangan kompleks target, di mana angka yang ditetapkan mungkin kompleks atau dengan jenis yang sama seperti bagian nyata dan imajiner dari bilangan kompleks tempat angka tersebut ditetapkan.

`complex`

Membuat bilangan kompleks dengan bagian nyata dan imajiner tertentu atau sebagai salinan dari beberapa bilangan kompleks lainnya.

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

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

Parameter

_RealVal
Nilai bagian nyata yang digunakan untuk menginisialisasi bilangan kompleks yang sedang dibangun.

_ImagVal
Nilai bagian imajiner yang digunakan untuk menginisialisasi bilangan kompleks yang sedang dibangun.

complexNum
Bilangan kompleks yang bagian nyata dan imajinernya digunakan untuk menginisialisasi bilangan kompleks yang sedang dibangun.

Keterangan

Konstruktor pertama menginisialisasi bagian nyata yang disimpan ke _RealVal dan bagian imajiner yang disimpan ke _Imagval. Konstruktor kedua menginisialisasi bagian nyata yang disimpan ke complexNum.real() dan bagian imajiner yang disimpan ke complexNum.imag().

Dalam implementasi ini, jika penerjemah tidak mendukung fungsi templat anggota, templat:

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

diganti dengan:

complex(const complex& right);

yang merupakan konstruktor salinan.

Contoh

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

Mengekstrak komponen imajiner dari bilangan kompleks.

T imag() const;

T imag(const T& right);

Parameter

right
Bilangan kompleks yang nilai imajinernya akan diekstrak.

Tampilkan Nilai

Bagian imajiner dari bilangan kompleks.

Keterangan

Untuk bilangan kompleks a + bi, bagian atau komponen imajinernya adalah Im(a + bi) = b.

Contoh

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

Mengalikan bilangan kompleks target dengan faktor, yang mungkin kompleks atau merupakan jenis yang sama seperti bagian nyata dan imajiner dari bilangan kompleks.

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

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

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

Parameter

right
Bilangan kompleks atau angka dengan jenis yang sama dengan parameter bilangan kompleks target.

Tampilkan Nilai

Bilangan kompleks yang telah dikalikan dengan angka yang ditentukan sebagai parameter.

Keterangan

Operasi kelebihan beban sehingga operasi aritmatika sederhana dapat dijalankan tanpa konversi data ke format tertentu.

Contoh

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

Menambahkan angka ke bilangan kompleks target, di mana angka yang ditambahkan mungkin kompleks atau dengan jenis yang sama seperti bagian nyata dan imajiner dari bilangan kompleks yang ditambahkannya.

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

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

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

Parameter

right
Bilangan kompleks atau angka dengan jenis yang sama dengan parameter bilangan kompleks target.

Tampilkan Nilai

Bilangan kompleks yang telah memiliki angka yang ditentukan sebagai parameter yang ditambahkan.

Keterangan

Operasi kelebihan beban sehingga operasi aritmatika sederhana dapat dijalankan tanpa konversi data ke format tertentu.

Contoh

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

Mengurangi angka dari bilangan kompleks target, di mana angka yang dikurangi mungkin kompleks atau dengan jenis yang sama seperti bagian nyata dan imajiner dari bilangan kompleks yang ditambahkannya.

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

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

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

Parameter

complexNum
Bilangan kompleks yang akan dikurangi dari bilangan kompleks target.

_RealPart
Bilangan riil yang akan dikurangi dari bilangan kompleks target.

Tampilkan Nilai

Bilangan kompleks yang telah memiliki angka yang ditentukan sebagai parameter yang dikurangi darinya.

Keterangan

Operasi kelebihan beban sehingga operasi aritmatika sederhana dapat dijalankan tanpa konversi data ke format tertentu.

Contoh

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

Membagi bilangan kompleks target dengan pembagi, yang mungkin kompleks atau merupakan jenis yang sama seperti bagian nyata dan imajiner dari bilangan kompleks.

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

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

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

Parameter

complexNum
Bilangan kompleks yang akan dikurangi dari bilangan kompleks target.

_RealPart
Bilangan riil yang akan dikurangi dari bilangan kompleks target.

Tampilkan Nilai

Bilangan kompleks yang telah dibagi dengan angka yang ditentukan sebagai parameter.

Keterangan

Operasi kelebihan beban sehingga operasi aritmatika sederhana dapat dijalankan tanpa konversi data ke format tertentu.

Contoh

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

Menetapkan angka ke bilangan kompleks target, di mana angka yang ditetapkan mungkin kompleks atau dengan jenis yang sama seperti bagian nyata dan imajiner dari bilangan kompleks tempat angka tersebut ditetapkan.

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

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

Parameter

right
Bilangan kompleks atau angka dengan jenis yang sama dengan parameter bilangan kompleks target.

Tampilkan Nilai

Bilangan kompleks yang telah ditetapkan angka yang ditentukan sebagai parameter.

Keterangan

Operasi kelebihan beban sehingga operasi aritmatika sederhana dapat dijalankan tanpa konversi data ke format tertentu.

Contoh

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

Mendapatkan atau mengatur real komponen bilangan kompleks.

constexpr T real() const;

T real(const T& right);

Parameter

right
Bilangan kompleks yang nilainya real akan diekstrak.

Tampilkan Nilai

Bagian real dari bilangan kompleks.

Keterangan

Untuk bilangan kompleks a + bi, real bagian atau komponennya adalah Re(a + bi) = a.

Contoh

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

Jenis yang mewakili jenis data yang digunakan untuk mewakili bagian nyata dan imajiner dari bilangan kompleks.

typedef Type value_type;

Keterangan

value_type adalah sinonim untuk parameter templat kompleks Type kelas.

Contoh

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

Lihat juga

Keamanan utas di Pustaka Standar C++

Bagikan melalui

complex Kelas

Sintaks

Keterangan

Anggota

Konstruktor

Typedefs

Fungsi

Operator

complex

Parameter

Keterangan

Contoh

imag

Parameter

Tampilkan Nilai

Keterangan

Contoh

operator*=

Parameter

Tampilkan Nilai

Keterangan

Contoh

operator+=

Parameter

Tampilkan Nilai

Keterangan

Contoh

operator-=

Parameter

Tampilkan Nilai

Keterangan

Contoh

operator/=

Parameter

Tampilkan Nilai

Keterangan

Contoh

operator=

Parameter

Tampilkan Nilai

Keterangan

Contoh

real

Parameter

Tampilkan Nilai

Keterangan

Contoh

value_type

Keterangan

Contoh

Lihat juga

Saran dan Komentar

Sumber Daya Tambahan:

`complex` Kelas

`complex`

`imag`

`operator*=`

`operator+=`

`operator-=`

`operator/=`

`operator=`

`real`

`value_type`