std:: complex
| 
           定义于头文件
            
            
             <complex>
            
            | ||
| 
           
            
             template
            
            
             <
            
            
             class
            
            T
            
             >
            
             class complex ; | (1) | |
| 
           
            
             template
            
            
             <>
            
            
             class
            
            complex
            
             <
            
            
             float
            
            
             >
            
            
             ;
            
           
           | (2) | (C++23 前) | 
| 
           
            
             template
            
            
             <>
            
            
             class
            
            complex
            
             <
            
            
             double
            
            
             >
            
            
             ;
            
           
           | (3) | (C++23 前) | 
| 
           
            
             template
            
            
             <>
            
            
             class
            
            complex
            
             <
            
            
             long
            
            
             double
            
            
             >
            
            
             ;
            
           
           | (4) | (C++23 前) | 
       针对无cv限定符
       
        
         标准
        
        
         
          (C++23 前)
         
        
       
       
        浮点类型
       
       的
       
        std::complex
       
       特化是
       
        
         
          
           可平凡复制
          
         
        
        
         
          (C++23 起)
         
        
       
       的
       
        
         字面类型
        
       
       ,用于表示和操作
       
        复数
       
       。
      
| 目录 | 
模板参数
| T | - | 实部与虚部的类型。若 
          T
         不是 cv 未限定的
         
          
           标准
          
          
           
            (C++23 前)
           
          
         
         浮点类型,则行为未指明(且可能编译失败);若
          T
         不符合
         
          
           数值类型要求
          
         
         ,则行为未定义。 | 
成员类型
| 成员类型 | 定义 | 
| 
          value_type
          | 
          T
          | 
成员函数
| 构造复数 (公开成员函数) | |
| 赋值内容 (公开成员函数) | |
| 访问复数的实部 (公开成员函数) | |
| 访问复数的虚部 (公开成员函数) | |
| 两个复数或一个复数与标量的复合赋值 (公开成员函数) | 
非成员函数
| 对复数应用一元运算符 (函数模板) | |
| 对两个复数或复数与标量执行复数算术运算 (函数模板) | |
| 
           
            
            
            
             
              (C++20 中移除)
             
            
           
           | 比较两个复数或复数与标量 (函数模板) | 
| 序列化与反序列化复数 (函数模板) | |
| 
           
            
             
              (C++26)
             
            
           
           | 从
         
          
           std::complex
          
         
         获取实部或虚部的引用 (函数模板) | 
| 返回实部 (函数模板) | |
| 返回虚部 (函数模板) | |
| 返回复数的模 (函数模板) | |
| 返回相位角 (函数模板) | |
| 返回模的平方 (函数模板) | |
| 返回复共轭 (函数模板) | |
| 
           
            
             
              (C++11)
             
            
           
           | 返回黎曼球面上的投影 (函数模板) | 
| 通过模和相位角构造复数 (函数模板) | |
| 指数函数 | |
| 复数以
         
          e
         
         为底的指数 (函数模板) | |
| 沿负实轴分割的复自然对数 (函数模板) | |
| 沿负实轴分割的复常用对数 (函数模板) | |
| 幂函数 | |
| 复幂运算,一个或两个参数可以是复数 (函数模板) | |
| 右半平面范围内的复平方根 (函数模板) | |
| 三角函数 | |
| 计算复数的正弦 (
         
         
          sin(z)
         
         ) (函数模板) | |
| 计算复数的余弦 (
         
         
          cos(z)
         
         ) (函数模板) | |
| 计算复数的正切 (
         
         
          tan(z)
         
         ) (函数模板) | |
辅助类型
| 
           
            
             
              (C++26)
             
            
           
           | 获取
         
          
           std::complex
          
         
         的大小 (类模板特化) | 
| 获取
         
          
           std::complex
          
         
         的底层实数和虚数类型 (类模板特化) | 
数组式访问
       对于任何类型为
       
        std::complex<T>
       
       的对象
       
        
         z
        
       
       ,
       
        
         
          reinterpret_cast
         
         
          <
         
         T
         
          (
         
         
          &
         
         
          )
         
         
          [
         
         
          2
         
         
          ]
         
         
          >
         
         
          (
         
         z
         
          )
         
         
          [
         
         
          0
         
         
          ]
         
        
       
       表示
       
        
         z
        
       
       的实部,而
       
        
         
          reinterpret_cast
         
         
          <
         
         T
         
          (
         
         
          &
         
         
          )
         
         
          [
         
         
          2
         
         
          ]
         
         
          >
         
         
          (
         
         z
         
          )
         
         
          [
         
         
          1
         
         
          ]
         
        
       
       表示
       
        
         z
        
       
       的虚部。
      
       对于指向
       
        std::complex<T>
       
       数组元素的任何指针
       
        
         p
        
       
       和任何有效的数组索引
       
        
         i
        
       
       ,
       
        
         
          reinterpret_cast
         
         
          <
         
         T
         
          *
         
         
          >
         
         
          (
         
         p
         
          )
         
         
          [
         
         
          2
         
         
          *
         
         i
         
          ]
         
        
       
       是复数
       
        
         p
         
          [
         
         i
         
          ]
         
        
       
       的实部,而
       
        
         
          reinterpret_cast
         
         
          <
         
         T
         
          *
         
         
          >
         
         
          (
         
         p
         
          )
         
         
          [
         
         
          2
         
         
          *
         
         i
         
          +
         
         
          1
         
         
          ]
         
        
       
       是复数
       
        
         p
         
          [
         
         i
         
          ]
         
        
       
       的虚部。
      
此要求的目的是为了保持 C++ 库复数类型与 C 语言复数类型 (及其数组)之间的二进制兼容性,这两者具有相同的对象表示要求。
实现说明
       为满足面向数组访问的需求,实现必须将
       
        std::complex
       
       特化的实部与虚部存储于独立且相邻的内存位置。其非静态数据成员的可能声明包括:
      
- 
        一个类型为
        value_type[2]的数组,第一个元素保存实部,第二个元素保存虚部(例如 Microsoft Visual Studio);
- 
        一个类型为
        value_type _Complex的单独成员(封装了对应的 C 语言复数类型 )(例如 GNU libstdc++);
- 
        两个类型为
        value_type的成员,具有相同的成员访问权限,分别保存实部和虚部(例如 LLVM libc++)。
       实现不能声明额外的非静态数据成员,这些成员会占用与实部和虚部分离的存储空间,并且必须确保类模板特化不包含任何
       
        填充位
       
       。实现还必须确保对数组访问的优化要考虑到指向
       
        value_type
       
       的指针可能正在别名化
       
        std::complex
       
       特化或其数组的可能性。
      
字面量
| 
          定义于内联命名空间
           
           std::literals::complex_literals
           | |
| 表示纯虚数的
         
          
           std::complex
          
         
         字面量 (函数) | |
注释
| 功能测试 宏 | 值 | 标准 | 功能 | 
|---|---|---|---|
| 
           __cpp_lib_constexpr_complex
           | 
           201711L
           | (C++20) | <complex> 中的 constexpr 简单复数数学函数 | 
| 
           202306L
           | (C++26) | 为 <complex> 增加更多 constexpr 支持 | |
| 
           __cpp_lib_tuple_like
           | 
           202311L
           | (C++26) | 为 
          std::complex
         添加元组协议支持 | 
示例
#include <cmath> #include <complex> #include <iomanip> #include <iostream> #include <ranges> int main() { using namespace std::complex_literals; std::cout << std::fixed << std::setprecision(1); std::complex<double> z1 = 1i * 1i; // 虚数单位平方 std::cout << "i * i = " << z1 << '\n'; std::complex<double> z2 = std::pow(1i, 2); // 虚数单位平方 std::cout << "pow(i, 2) = " << z2 << '\n'; const double PI = std::acos(-1); // 或在 C++20 中使用 std::numbers::pi std::complex<double> z3 = std::exp(1i * PI); // 欧拉公式 std::cout << "exp(i * pi) = " << z3 << '\n'; std::complex<double> z4 = 1.0 + 2i, z5 = 1.0 - 2i; // 共轭复数 std::cout << "(1 + 2i) * (1 - 2i) = " << z4 * z5 << '\n'; const auto zz = {0.0 + 1i, 2.0 + 3i, 4.0 + 5i}; #if __cpp_lib_tuple_like >= 202311L for (double re : zz | std::views::keys) std::cout << re << ' '; std::cout << '\n'; for (double im : zz | std::views::values) std::cout << im << ' '; std::cout << '\n'; #else for (double re : zz | std::views::transform([](auto z){ return z.real(); })) std::cout << re << ' '; std::cout << '\n'; for (double im : zz | std::views::transform([](auto z){ return z.imag(); })) std::cout << im << ' '; std::cout << '\n'; #endif }
输出:
i * i = (-1.0,0.0) pow(i, 2) = (-1.0,0.0) exp(i * pi) = (-1.0,0.0) (1 + 2i) * (1 - 2i) = (5.0,0.0) 0.0 2.0 4.0 1.0 3.0 5.0
缺陷报告
下列行为变更缺陷报告被追溯应用于先前发布的C++标准。
| 缺陷报告 | 适用范围 | 发布时的行为 | 正确行为 | 
|---|---|---|---|
| LWG 387 | C++98 | 
          std::complex
         未保证与 C
          complex
         兼容 | 保证兼容 | 
参见
| 
          
           
            C 文档
           
          
          关于
          
           
            复数运算
           
          
          |