C std::complex number example

std::complex is used to simplify complex operations in C. 1. It needs to include the <complex> header file; 2. You can use std::complex<double> (real part, imaginary part) to create complex numbers; 3. Support basic operations such as -, *, /; 4. Access the real imaginary parts through real() and imag(); 5. Use abs() to find the modulus, arg() to find the amplitude angle, norm() to find the modulus square; 6. conj() returns conjugated complex numbers; 7. exp() combines imaginary units to verify the Euler formula; 8. The polar() function can create complex numbers from polar coordinates. This template avoids manual implementation of complex operations and is widely used in fields such as mathematics and signal processing.

Here's a practical example of using std::complex in C:

Basic Usage of std::complex

The std::complex template in C (from the <complex></complex> header) lets you work with complex numbers easily. Here's a simple example showing creation, arithmetic, and common operations:

 #include <iostream>
#include <complex>
#include <cmath>

int main() {
    // Create complex numbers
    std::complex<double> z1(3.0, 4.0); // 3 4i
    std::complex<double> z2(1.0, -2.0); // 1 - 2i

    // Output them
    std::cout << "z1 = " << z1 << std::endl; // Output: (3,4)
    std::cout << "z2 = " << z2 << std::endl; // Output: (1,-2)

    // Arithmetic operations
    std::cout << "z1 z2 = " << (z1 z2) << std::endl; // (4,2)
    std::cout << "z1 - z2 = " << (z1 - z2) << std::endl; // (2,6)
    std::cout << "z1 * z2 = " << (z1 * z2) << std::endl; // (11,-2)
    std::cout << "z1 / z2 = " << (z1 / z2) << std::endl; // (-1,2)

    // Access real and imaginary parts
    std::cout << "Re(z1) = " << z1.real() << std::endl; // 3
    std::cout << "Im(z1) = " << z1.imag() << std::endl; // 4

    // Magnitude and phase
    std::cout << "abs(z1) = " << std::abs(z1) << std::endl; // 5
    std::cout << "arg(z1) = " << std::arg(z1) << std::endl; // ~0.927 (radians)
    std::cout << "norm(z1) = " << std::norm(z1) << std::endl; // 25 (|z|²)

    // Complex conjugate
    std::cout << "conj(z1) = " << std::conj(z1) << std::endl; // (3,-4)

    // Euler&#39;s formula: e^(iπ) = -1
    std::complex<double> i(0, 1); // Imaginary unit
    std::complex<double> result = std::exp(i * M_PI);
    std::cout << "e^(i*pi) = " << result << std::endl; // Should be close to (-1,0)

    return 0;
}

Key Points

• Header : Always include <complex>
• Template types : Commonly std::complex<double> , but float and long double are also supported
• Construction : std::complex<double>(real, imag) or direct assignment like {a, b}
• Operators : , - , * , / work as expected
• Functions : std::abs , std::arg , std::conj , std::norm , std::exp , std::polar , etc.

Using polar form

You can also create complex numbers from magnitude and phase:

 double magnitude = 5.0;
double angle = M_PI / 3; // 60 degrees
std::complex<double> z_polar = std::polar(magnitude, angle);
std::cout << "Polar to rectangular: " << z_polar << std::endl;

This is especially useful in signal processing or physics simulations.

Basically, std::complex handles the math so you don't have to implement complex arithmetic manually — and it integrates well with standard math functions.

The above is the detailed content of C std::complex number example. For more information, please follow other related articles on the PHP Chinese website!