1. 项目概述与核心价值如果你正在学习C面向对象编程或者准备面试那么“实现一个复数类”这个项目你大概率绕不过去。这几乎是C课程设计、面试手撕代码的经典题目。很多人会觉得C标准库不是已经有std::complex了吗为什么还要自己造轮子这个问题问得好也正是这个项目的核心价值所在。自己动手实现一个复数类远不止是为了得到一个能算加减乘除的工具。它的真正意义在于它是一个绝佳的、浓缩的C面向对象特性与运算符重载的实战沙箱。通过这一个类你可以把构造函数、拷贝控制、运算符重载,-,*,/,,,等、友元函数、类型转换、常量成员函数等核心知识点串起来进行一次综合演练。这比孤立地看每一个知识点要深刻得多。你会在实现过程中真切地体会到什么是封装、如何设计接口、哪些操作应该作为成员函数、哪些应该作为非成员友元函数以及如何保证代码的异常安全性和效率。对于初学者这是从“知道语法”到“会用语法解决实际问题”的关键一步对于面试者这是展示你C基本功是否扎实的试金石。一个写得漂亮、考虑周全的复数类能体现出程序员对语言特性的理解深度和工程素养。所以别把它当成一个简单的数学练习而应视为一次完整的C小型项目开发。2. 复数类的核心设计思路在动手写代码之前我们先得把设计思路理清楚。一个复数数学上表示为a bi其中a是实部realb是虚部imaginaryi是虚数单位。在C里我们自然想到用两个浮点数double类型的私有成员变量来存储它们。2.1 成员变量与封装性首先确定数据成员。为了通用性和精度我们选择double类型来存储实部和虚部。将它们设为private这是封装性的基本要求防止外部代码随意修改内部数据保证对象状态的一致性。class Complex { private: double real_; // 实部后缀下划线是一种常见的命名约定用于区分成员变量 double imag_; // 虚部 };这里用了real_和imag_这种带下划线的命名。这是一种风格旨在明确区分成员变量和局部变量/参数。你也可以用m_real、m_imag或者不加修饰。关键是团队或个人风格要统一。2.2 构造函数的设计灵活性与效率构造函数是对象的出生证明。我们需要考虑用户创建复数对象的多种方式同时指定实部和虚部Complex c1(3.0, 4.0);// 3 4i只指定实部虚部为0Complex c2(5.0);// 5 0i不指定任何参数默认构造函数Complex c3;// 0 0i通过另一个复数对象创建拷贝构造函数Complex c4(c1);为了覆盖这些场景我们需要提供多个构造函数。这里可以利用C的函数默认参数和委托构造函数C11起来优雅地实现。class Complex { public: // 默认构造函数委托给双参数构造函数 Complex() : Complex(0.0, 0.0) {} // 单参数构造函数实部虚部默认为0.0 explicit Complex(double re) : Complex(re, 0.0) {} // 核心构造函数初始化实部和虚部 Complex(double re, double im) : real_(re), imag_(im) {} // 拷贝构造函数编译器默认生成的通常就够用但这里显式写出以供理解 Complex(const Complex other) default; private: double real_; double imag_; };注意explicit关键字用在单参数构造函数上。这很重要它防止了隐式类型转换。没有explicitComplex c 7.5;这样的语句是合法的编译器会隐式地将7.5转换为Complex(7.5)。但这可能带来意想不到的行为比如函数传参时的隐式转换可能导致歧义。加上explicit后这种写法就必须是Complex c(7.5);或Complex c Complex(7.5);意图更清晰。2.3 运算符重载的策略成员函数 vs. 非成员友元函数这是设计的重中之重。运算符重载可以让我们的复数类用起来像内置类型一样自然比如c1 c2,c1 c2,cout c1。何时用成员函数对于会修改左侧操作数左值的运算符如,-,*,/通常重载为成员函数。因为它们需要直接访问左侧对象的私有成员。Complex operator(const Complex rhs) { real_ rhs.real_; imag_ rhs.imag_; return *this; // 返回引用以支持链式调用如 (a b) c }何时用非成员通常是友元函数对于不修改操作数、产生新值的运算符如,-,*,/以及输入输出流运算符,通常重载为非成员函数。这保证了运算符的对称性。例如对于c1 5.2如果operator是成员函数那么它可以工作但对于5.2 c1编译器不会将5.2隐式转换为Complex然后调用成员函数除非构造函数不是explicit且我们允许隐式转换但这通常不是好主意。而非成员函数可以平等地对待两个参数。// 在类内声明为友元使其能访问私有成员 friend Complex operator(const Complex lhs, const Complex rhs); // 在类外定义 Complex operator(const Complex lhs, const Complex rhs) { return Complex(lhs.real_ rhs.real_, lhs.imag_ rhs.imag_); }流运算符的重载这是一个经典的非成员友元函数用例。它接收一个std::ostream和一个const Complex并返回同一个ostream引用以支持链式输出。class Complex { friend std::ostream operator(std::ostream os, const Complex c); }; std::ostream operator(std::ostream os, const Complex c) { os ( c.real_ , c.imag_ ); // 输出格式如 (3, 4) return os; }2.4 常成员函数与取值函数对于不修改对象状态的成员函数一定要加上const修饰符。这是良好的接口设计它允许const对象调用这些函数同时也向使用者清晰地表明了函数的语义。double real() const { return real_; } // 获取实部不修改对象 double imag() const { return imag_; } // 获取虚部不修改对象3. 核心功能实现与代码详解有了清晰的设计思路我们现在来逐一实现复数类的核心功能。我会给出完整的代码片段并解释其中的关键点和注意事项。3.1 类的骨架与基础成员首先搭建类的整体框架包含数据成员、构造函数、基本的取值函数。// Complex.h #ifndef COMPLEX_H // 头文件保护防止重复包含 #define COMPLEX_H #include iostream class Complex { public: // 构造函数 Complex() : real_(0.0), imag_(0.0) {} // 默认构造初始化为00i explicit Complex(double real) : real_(real), imag_(0.0) {} // 仅实部 Complex(double real, double imag) : real_(real), imag_(imag) {} // 完整构造 // 拷贝构造函数和拷贝赋值运算符使用编译器默认版本即可 Complex(const Complex) default; Complex operator(const Complex) default; // 析构函数使用编译器默认版本 ~Complex() default; // 取值函数 - 声明为const不修改对象 double real() const { return real_; } double imag() const { return imag_; } // 设值函数根据需求可选 void set_real(double real) { real_ real; } void set_imag(double imag) { imag_ imag; } // 后续将在这里添加运算符重载和其他成员函数的声明... private: double real_; // 实部 double imag_; // 虚部 }; #endif // COMPLEX_H注意这里我提供了set_real和set_imag函数。在严格的封装设计中如果你不希望对象创建后被随意修改可以不提供这两个函数或者只提供返回内部数据引用的函数但要谨慎这会破坏封装。一个更“函数式”的设计是所有操作都返回新的Complex对象原对象不可变。3.2 算术赋值运算符的实现, -, *, /这些运算符修改自身并返回自身的引用以支持链式操作。它们的实现需要一些复数运算的数学知识。// 在Complex类public区域声明 Complex operator(const Complex rhs); Complex operator-(const Complex rhs); Complex operator*(const Complex rhs); Complex operator/(const Complex rhs);// Complex.cpp (或直接在头文件内实现如果选择头文件内联的话) Complex Complex::operator(const Complex rhs) { real_ rhs.real_; imag_ rhs.imag_; return *this; // 返回当前对象的引用 } Complex Complex::operator-(const Complex rhs) { real_ - rhs.real_; imag_ - rhs.imag_; return *this; } Complex Complex::operator*(const Complex rhs) { // (abi) * (cdi) (ac-bd) (adbc)i double new_real real_ * rhs.real_ - imag_ * rhs.imag_; double new_imag real_ * rhs.imag_ imag_ * rhs.real_; real_ new_real; imag_ new_imag; return *this; } Complex Complex::operator/(const Complex rhs) { // (abi) / (cdi) [(abi)(c-di)] / (c^2d^2) double denominator rhs.real_ * rhs.real_ rhs.imag_ * rhs.imag_; if (denominator 0.0) { // 处理除零错误可以抛出异常或返回一个特殊值如NaN // 这里简单处理实际项目应更严谨 throw std::runtime_error(Complex division by zero); } double new_real (real_ * rhs.real_ imag_ * rhs.imag_) / denominator; double new_imag (imag_ * rhs.real_ - real_ * rhs.imag_) / denominator; real_ new_real; imag_ new_imag; return *this; }实操心得实现operator*和operator/时最容易犯的错误是直接修改real_后又用这个已经改变的值去计算imag_。比如在*中如果先写real_ real_ * rhs.real_ - imag_ * rhs.imag_;那么下一行计算imag_时用的real_已经是新值了结果必然错误。必须先用临时变量保存计算结果最后再一次性赋值给成员变量。这是一个经典的陷阱。3.3 二元算术运算符的实现, -, *, /这些运算符不修改操作数而是返回一个新的复数对象。通常利用上面已经实现的等运算符来实现这样更简洁且不易出错。// 在类内声明为友元函数以便访问私有成员 friend Complex operator(const Complex lhs, const Complex rhs); friend Complex operator-(const Complex lhs, const Complex rhs); friend Complex operator*(const Complex lhs, const Complex rhs); friend Complex operator/(const Complex lhs, const Complex rhs);// 非成员函数在类外定义 Complex operator(const Complex lhs, const Complex rhs) { Complex result lhs; // 拷贝构造左操作数 result rhs; // 利用已经实现的 return result; // 返回值可能触发NRVO优化 } Complex operator-(const Complex lhs, const Complex rhs) { Complex result lhs; result - rhs; return result; } Complex operator*(const Complex lhs, const Complex rhs) { Complex result lhs; result * rhs; return result; } Complex operator/(const Complex lhs, const Complex rhs) { Complex result lhs; result / rhs; return result; }这种“通过op来实现op”的模式非常优雅。它遵循了DRYDon‘t Repeat Yourself原则算术逻辑只写一遍在op中op只是调用它。这不仅减少了代码量更重要的是保证了行为的一致性任何对op的修正都会自动应用到op上。3.4 比较运算符的实现, !复数相等的定义是实部和虚部都分别相等。由于我们使用double类型直接使用比较浮点数是有风险的因为浮点数计算存在精度误差。更稳健的做法是判断两个数的差是否在一个极小的误差范围内epsilon。// 在类内声明 friend bool operator(const Complex lhs, const Complex rhs); friend bool operator!(const Complex lhs, const Complex rhs);// 定义一个比较精度 const double EPSILON 1e-10; bool operator(const Complex lhs, const Complex rhs) { // 分别比较实部和虚部考虑精度误差 return (std::abs(lhs.real_ - rhs.real_) EPSILON) (std::abs(lhs.imag_ - rhs.imag_) EPSILON); } bool operator!(const Complex lhs, const Complex rhs) { return !(lhs rhs); // 复用 operator }注意事项EPSILON的值需要根据实际应用的精度要求来设定。对于科学计算可能需要更小的值如1e-15对于图形学等可能1e-6就够了。也可以提供一个可配置的容差参数。另外operator!通常直接通过operator来实现逻辑清晰且不易出错。3.5 流运算符的实现, 输出运算符我们已经见过。输入运算符需要从流中解析数据格式。我们约定输入格式为(real, imag)或real imag。// 类内声明 friend std::ostream operator(std::ostream os, const Complex c); friend std::istream operator(std::istream is, Complex c);std::ostream operator(std::ostream os, const Complex c) { // 输出格式化为 (real, imag)模仿数学和std::complex的习惯 os ( c.real_ , c.imag_ ); return os; } std::istream operator(std::istream is, Complex c) { // 尝试读取格式为 (real, imag) char ch; if (is ch ch () { double real, imag; char comma; if (is real comma imag comma ,) { if (is ch ch )) { c.real_ real; c.imag_ imag; } else { is.setstate(std::ios_base::failbit); // 格式错误设置失败位 } } else { is.setstate(std::ios_base::failbit); } } else { // 如果不是(开头则回退字符尝试读取两个独立的数字 is.putback(ch); double real, imag; if (is real imag) { c.real_ real; c.imag_ imag; } else { is.setstate(std::ios_base::failbit); } } return is; }踩坑记录实现operator时流的错误处理非常重要。上面的代码在每一步都检查了读取是否成功以及格式是否符合预期。如果失败我们使用is.setstate(std::ios_base::failbit)来设置流的失败状态这样使用者就可以通过if (std::cin myComplex)来判断输入是否成功。这是一个健壮的operator应该具备的特性。3.6 其他常用成员函数除了基本运算一个完整的复数类通常还提供一些常用的数学函数。class Complex { public: // ... 之前的成员 ... // 计算模长绝对值 |z| sqrt(real^2 imag^2) double abs() const { return std::sqrt(real_ * real_ imag_ * imag_); } // 计算辐角相位 arg(z) atan2(imag, real) // 返回值在 [-π, π] 之间 double arg() const { return std::atan2(imag_, real_); } // 计算共轭复数 conj(abi) a-bi Complex conj() const { return Complex(real_, -imag_); } // 静态函数从极坐标创建复数 // r: 模长, theta: 辐角弧度 static Complex from_polar(double r, double theta) { return Complex(r * std::cos(theta), r * std::sin(theta)); } };这些函数都声明为const因为它们不修改对象状态。from_polar是一个静态成员函数它不属于任何对象而是属于类本身调用方式为Complex::from_polar(5.0, M_PI/4)。4. 完整代码示例与测试现在我们把所有部分组合起来形成一个完整的头文件并编写一个简单的测试程序来验证功能。4.1 Complex.h 完整头文件// Complex.h #ifndef COMPLEX_H #define COMPLEX_H #include iostream #include cmath #include stdexcept class Complex { public: // 构造函数 Complex() : real_(0.0), imag_(0.0) {} explicit Complex(double real) : real_(real), imag_(0.0) {} Complex(double real, double imag) : real_(real), imag_(imag) {} // 默认的拷贝控制成员 Complex(const Complex) default; Complex operator(const Complex) default; ~Complex() default; // 取值函数 double real() const { return real_; } double imag() const { return imag_; } // 设值函数可选 void set_real(double real) { real_ real; } void set_imag(double imag) { imag_ imag; } // 复合赋值运算符 Complex operator(const Complex rhs); Complex operator-(const Complex rhs); Complex operator*(const Complex rhs); Complex operator/(const Complex rhs); // 数学函数 double abs() const { return std::sqrt(real_ * real_ imag_ * imag_); } double arg() const { return std::atan2(imag_, real_); } Complex conj() const { return Complex(real_, -imag_); } static Complex from_polar(double r, double theta); // 友元声明非成员运算符 friend bool operator(const Complex lhs, const Complex rhs); friend bool operator!(const Complex lhs, const Complex rhs); friend Complex operator(const Complex lhs, const Complex rhs); friend Complex operator-(const Complex lhs, const Complex rhs); friend Complex operator*(const Complex lhs, const Complex rhs); friend Complex operator/(const Complex lhs, const Complex rhs); friend std::ostream operator(std::ostream os, const Complex c); friend std::istream operator(std::istream is, Complex c); private: double real_; double imag_; }; // 内联实现复合赋值运算符也可以放在.cpp文件 inline Complex Complex::operator(const Complex rhs) { real_ rhs.real_; imag_ rhs.imag_; return *this; } inline Complex Complex::operator-(const Complex rhs) { real_ - rhs.real_; imag_ - rhs.imag_; return *this; } inline Complex Complex::operator*(const Complex rhs) { double new_real real_ * rhs.real_ - imag_ * rhs.imag_; double new_imag real_ * rhs.imag_ imag_ * rhs.real_; real_ new_real; imag_ new_imag; return *this; } inline Complex Complex::operator/(const Complex rhs) { double denominator rhs.real_ * rhs.real_ rhs.imag_ * rhs.imag_; if (std::abs(denominator) 1e-15) { // 使用更稳健的除零判断 throw std::runtime_error(Complex division by zero); } double new_real (real_ * rhs.real_ imag_ * rhs.imag_) / denominator; double new_imag (imag_ * rhs.real_ - real_ * rhs.imag_) / denominator; real_ new_real; imag_ new_imag; return *this; } // 内联实现静态成员函数 inline Complex Complex::from_polar(double r, double theta) { return Complex(r * std::cos(theta), r * std::sin(theta)); } // 非成员运算符的内联实现通常放在头文件 inline bool operator(const Complex lhs, const Complex rhs) { const double EPSILON 1e-10; return (std::abs(lhs.real_ - rhs.real_) EPSILON) (std::abs(lhs.imag_ - rhs.imag_) EPSILON); } inline bool operator!(const Complex lhs, const Complex rhs) { return !(lhs rhs); } inline Complex operator(const Complex lhs, const Complex rhs) { Complex result lhs; result rhs; return result; } inline Complex operator-(const Complex lhs, const Complex rhs) { Complex result lhs; result - rhs; return result; } inline Complex operator*(const Complex lhs, const Complex rhs) { Complex result lhs; result * rhs; return result; } inline Complex operator/(const Complex lhs, const Complex rhs) { Complex result lhs; result / rhs; return result; } inline std::ostream operator(std::ostream os, const Complex c) { os ( c.real_ , c.imag_ ); return os; } // operator 实现较长通常放在.cpp文件但为了示例完整也内联在此 inline std::istream operator(std::istream is, Complex c) { double real 0.0, imag 0.0; char ch; if (is ch ch () { char comma; if (is real comma imag comma ,) { if (is ch ch )) { c.real_ real; c.imag_ imag; } else { is.setstate(std::ios_base::failbit); } } else { is.setstate(std::ios_base::failbit); } } else { is.putback(ch); if (is real imag) { c.real_ real; c.imag_ imag; } else { is.setstate(std::ios_base::failbit); } } return is; } #endif // COMPLEX_H4.2 测试程序 main.cpp// main.cpp #include Complex.h #include iostream #include iomanip int main() { // 1. 测试构造函数和输出 Complex c1(3.0, 4.0); // 3 4i Complex c2(1.0, -2.0); // 1 - 2i Complex c3; // 0 0i Complex c4(5.0); // 5 0i std::cout c1 c1 std::endl; std::cout c2 c2 std::endl; std::cout c3 c3 std::endl; std::cout c4 c4 std::endl; // 2. 测试基本运算 Complex sum c1 c2; Complex diff c1 - c2; Complex prod c1 * c2; Complex quot c1 / c2; std::cout \n算术运算测试: std::endl; std::cout c1 c2 sum std::endl; std::cout c1 - c2 diff std::endl; std::cout c1 * c2 prod std::endl; std::cout c1 / c2 quot std::endl; // 3. 测试复合赋值运算 Complex c5 c1; // 拷贝构造 c5 c2; std::cout \n复合赋值测试: std::endl; std::cout c1 c2 后 c5 c5 std::endl; // 4. 测试数学函数 std::cout \n数学函数测试: std::endl; std::cout |c1| c1.abs() std::endl; std::cout arg(c1) c1.arg() radians std::endl; std::cout conj(c1) c1.conj() std::endl; // 5. 测试极坐标创建 Complex c6 Complex::from_polar(5.0, M_PI / 4); // 模5角度45度 std::cout \n极坐标创建测试: std::endl; std::cout from_polar(5, π/4) c6 std::endl; std::cout 其模长应为5: c6.abs() std::endl; std::cout 其辐角应为π/4: c6.arg() std::endl; // 6. 测试比较运算符 std::cout \n比较运算符测试: std::endl; std::cout std::boolalpha; // 让bool输出为true/false std::cout c1 c1? (c1 c1) std::endl; std::cout c1 c2? (c1 c2) std::endl; std::cout c1 ! c2? (c1 ! c2) std::endl; // 7. 测试输入可选在控制台输入 // Complex c7; // std::cout \n请输入一个复数 (格式如 (3,4) 或 3 4): ; // if (std::cin c7) { // std::cout 你输入的是: c7 std::endl; // } else { // std::cout 输入格式错误 std::endl; // std::cin.clear(); // 清除错误状态 // std::cin.ignore(std::numeric_limitsstd::streamsize::max(), \n); // 忽略错误输入 // } return 0; }编译并运行这个测试程序例如使用g -stdc11 main.cpp -o complex_test你应该能看到正确的输出验证了复数类的各项功能。5. 高级话题与扩展思考实现一个基础可用的复数类只是起点。在实际项目或深入学习中你可能会遇到更多需要考虑的问题。5.1 模板化设计我们当前的类只支持double类型。但复数也可以用float或long double表示。为了让类更通用可以将其设计为模板类。templatetypename T class ComplexTemplate { private: T real_; T imag_; public: ComplexTemplate(T re T(), T im T()) : real_(re), imag_(im) {} // ... 其他成员函数需要适当调整比如abs()需要std::sqrt支持T类型 ... };这样用户就可以使用ComplexTemplatefloat,ComplexTemplatedouble,ComplexTemplatelong double。但模板化会带来一些挑战比如需要确保类型T支持所需的算术运算并且数学函数如std::sqrt、std::atan2有对应的重载版本。std::complex本身就是一个模板类std::complexT。5.2 性能考量返回值优化与移动语义在我们的operator实现中我们创建了一个局部对象result并返回它。在C11之前这可能会导致一次不必要的拷贝返回值优化RVO/NRVO是编译器的优化不保证总是发生。C11引入了移动语义我们可以通过添加移动构造函数和移动赋值运算符来提升性能。class Complex { public: // ... 其他成员 ... // 移动构造函数 Complex(Complex other) noexcept : real_(std::move(other.real_)), imag_(std::move(other.imag_)) { // 将源对象置于有效但可析构的状态通常归零 other.real_ 0.0; other.imag_ 0.0; } // 移动赋值运算符 Complex operator(Complex other) noexcept { if (this ! other) { real_ std::move(other.real_); imag_ std::move(other.imag_); other.real_ 0.0; other.imag_ 0.0; } return *this; } };对于像Complex这样只包含两个double的简单类型移动操作带来的性能提升微乎其微因为拷贝两个double的成本极低。但对于管理大型资源的类如动态数组移动语义至关重要。这里实现它们主要是为了演示和养成良好习惯。5.3 异常安全我们在operator/中使用了throw std::runtime_error来处理除零错误。这是一个基本的异常安全考虑。更完善的异常安全保证如强异常安全要求操作要么完全成功要么完全失败且对象状态不变。我们的operator/在计算分母和临时结果后才修改成员基本满足基本保证。如果new_real和new_imag的计算过程可能抛出异常对于double运算基本不会那么我们需要更精细的设计比如先计算并存到局部变量最后用std::swap无异常抛出的交换操作来更新成员。5.4 与标准库的兼容性我们实现的复数类是一个教学示例。在实际开发中除非有特殊需求如需要特定的内存布局、定制化行为或学习目的否则强烈建议直接使用C标准库中的std::complexT。它经过千锤百炼是高度优化且完全符合标准的。我们的实现练习是为了理解其背后的原理和C语言特性而不是为了替代它。5.5 单元测试的重要性对于这样一个包含多种运算和边界条件的类编写单元测试是保证其正确性的关键。你可以使用Google Test、Catch2等测试框架为每一个运算符和成员函数编写测试用例覆盖正常情况、边界情况如除零和异常情况。6. 常见问题与排查技巧在实现和使用自定义复数类的过程中你可能会遇到一些典型问题。这里我总结了一份速查表。问题现象可能原因解决方案编译错误no match for operator1. 运算符重载函数声明/定义缺失或签名错误。2. 运算符被错误地声明为成员函数导致左侧操作数类型不匹配如double Complex。1. 检查头文件中是否正确定义了友元或非成员operator。2. 确保二元算术运算符,-,*,/通常定义为非成员友元函数。运算结果不正确特别是乘法和除法1. 乘法和除法的数学公式实现错误。2. 在operator*和operator/中直接修改了real_后又用其计算imag_导致使用了错误的值。1. 复核公式(abi)*(cdi) (ac-bd)(adbc)i(abi)/(cdi) [(acbd)(bc-ad)i]/(c²d²)。2.务必使用临时变量保存计算结果最后再赋值给成员变量。浮点数比较总是返回false直接使用比较两个计算得到的浮点数由于精度误差它们几乎不可能完全相等。使用容差比较法std::abs(a - b) EPSILON。根据应用场景选择合适的EPSILON值如1e-10。链式操作编译失败如(a b) coperator的返回值不是Complex左值引用而是Complex值。确保复合赋值运算符返回*this的引用Complex operator(const Complex rhs) { ... return *this; }。输入操作cin myComplex后流状态错误operator实现不健壮未能处理所有预期的输入格式或错误情况。在operator的每一步都检查流状态is.good()并在格式错误时调用is.setstate(std::ios::failbit)。在调用方检查输入是否成功if (cin c) { ... }。隐式转换导致意外行为如Complex c 5;可以编译单参数构造函数没有用explicit关键字修饰。除非有充分理由否则将单参数构造函数声明为explicit防止意外的隐式类型转换。代码重复例如和的逻辑几乎一样直接分别在operator和operator中实现了相似的逻辑。遵循“通过op来实现op”的惯例。在operator中调用operator保证逻辑一致且代码简洁。使用const对象调用real()或imag()编译失败成员函数real()和imag()没有声明为const。对于不修改对象状态的成员函数一律加上const修饰符double real() const { return real_; }。实现一个复数类就像完成一次C核心特性的微型综合项目。从数据封装、构造函数设计到运算符重载的策略选择、友元函数的运用再到异常安全、移动语义等进阶话题每一个环节都值得深思。最终的目标不是写出一个比std::complex更好的轮子而是在这个过程中将书本上离散的知识点编织成解决实际问题的能力。当你下次在面试中被要求手写一个复数类时希望这篇文章能帮你从容应对不仅写出能跑的代码更能讲出每个设计选择背后的“为什么”。
