### 设计思路 为了满足需求，这里提供两种实现方案：一种基于 **C++** 的实现，另一种基于 **Python** 的实现。以下是具体的设计细节： #### 功能模块划分 1. 初始化：支持多种形式的初始化。 2. 运算符重载：加法、减法、乘法、除法以及相等比较。 3. 模运算：计算复数的模。 4. 字符串输出：通过 `operator<<` 或者内置函数返回字符串表示形式。 5. 对象数量统计：记录创建的对象总数。 #### 文件结构 - C++ 版本分为头文件 `.h` 和源文件 `.cpp`，并附带测试代码。 - Python 版本则采用模块化设计，将不同功能拆分到独立的脚本中。 --- ### C++ 实现 #### 1. 头文件 (`Complex.h`) ```cpp #ifndef COMPLEX_H #define COMPLEX_H #include <iostream> #include <cmath> class Complex { public: static int objectCount; // 构造函数 Complex(double real = 0, double imag = 0); Complex(const std::string& str); // 获取实部和虚部 double getReal() const; double getImaginary() const; // 设置实部和虚部 void setReal(double real); void setImaginary(double imag); // 计算模 double modulus() const; // 运算符重载 Complex operator+(const Complex& other) const; Complex operator-(const Complex& other) const; Complex operator*(const Complex& other) const; Complex operator/(const Complex& other) const; bool operator==(const Complex& other) const; friend std::ostream& operator<<(std::ostream& os, const Complex& c); private: double _real; double _imaginary; }; #endif // COMPLEX_H ``` #### 2. 源文件 (`Complex.cpp`) ```cpp #include "Complex.h" int Complex::objectCount = 0; // 构造函数 Complex::Complex(double real, double imag) : _real(real), _imaginary(imag) { ++objectCount; } Complex::Complex(const std::string& str) { size_t pos = str.find('+'); if (pos != std::string::npos) { try { _real = std::stod(str.substr(0, pos)); _imaginary = std::stod(str.substr(pos + 1, str.size() - pos - 2)); // 去掉 'i' } catch (...) { throw std::invalid_argument("Invalid complex number format"); } } else { throw std::invalid_argument("Invalid complex number format"); } ++objectCount; } double Complex::getReal() const { return _real; } double Complex::getImaginary() const { return _imaginary; } void Complex::setReal(double real) { _real = real; } void Complex::setImaginary(double imag) { _imaginary = imag; } double Complex::modulus() const { return sqrt(_real * _real + _imaginary * _imaginary); // 使用标准库中的sqrt函数[^1] } Complex Complex::operator+(const Complex& other) const { return Complex(_real + other._real, _imaginary + other._imaginary); } Complex Complex::operator-(const Complex& other) const { return Complex(_real - other._real, _imaginary - other._imaginary); } Complex Complex::operator*(const Complex& other) const { double new_real = _real * other._real - _imaginary * other._imaginary; double new_imag = _real * other._imaginary + _imaginary * other._real; return Complex(new_real, new_imag); } Complex Complex::operator/(const Complex& other) const { double denominator = other._real * other._real + other._imaginary * other._imaginary; if (denominator == 0) { throw std::runtime_error("Division by zero error"); } double new_real = (_real * other._real + _imaginary * other._imaginary) / denominator; double new_imag = (-_real * other._imaginary + _imaginary * other._real) / denominator; return Complex(new_real, new_imag); } bool Complex::operator==(const Complex& other) const { return (_real == other._real && _imaginary == other._imaginary); } std::ostream& operator<<(std::ostream& os, const Complex& c) { os << c.getReal(); if (c.getImaginary() >= 0) os << "+"; os << c.getImaginary() << "i"; return os; } ``` #### 3. 测试文件 (`main.cpp`) ```cpp #include "Complex.h" #include <iostream> int main() { Complex c1(3, 4); Complex c2("5+12i"); std::cout << "Object count: " << Complex::objectCount << "\n"; std::cout << "c1: " << c1 << ", Modulus: " << c1.modulus() << "\n"; // 输出模 std::cout << "c2: " << c2 << ", Modulus: " << c2.modulus() << "\n"; Complex sum = c1 + c2; Complex diff = c1 - c2; Complex product = c1 * c2; Complex quotient = c1 / c2; std::cout << "Sum: " << sum << "\n"; std::cout << "Difference: " << diff << "\n"; std::cout << "Product: " << product << "\n"; std::cout << "Quotient: " << quotient << "\n"; return 0; } ``` --- ### Python 实现 #### 1. 主类定义 (`complex_class.py`) ```python import math class Complex: __object_count = 0 def __init__(self, real=0, imaginary=0): self.real = real self.imaginary = imaginary Complex.__object_count += 1 @classmethod def from_string(cls, s): parts = s.split("+") if len(parts) != 2 or not parts[1].endswith('i'): raise ValueError("Invalid complex string format") real = float(parts[0]) imaginary = float(parts[1][:-1]) # Remove the trailing 'i' return cls(real, imaginary) def modulus(self): return math.sqrt(self.real ** 2 + self.imaginary ** 2) # 使用math.sqrt计算平方根 def __add__(self, other): return Complex(self.real + other.real, self.imaginary + other.imaginary) def __sub__(self, other): return Complex(self.real - other.real, self.imaginary - other.imaginary) def __mul__(self, other): real_part = self.real * other.real - self.imaginary * other.imaginary imag_part = self.real * other.imaginary + self.imaginary * other.real return Complex(real_part, imag_part) def __truediv__(self, other): denom = other.real ** 2 + other.imaginary ** 2 if denom == 0: raise ZeroDivisionError("Cannot divide by zero") real_part = (self.real * other.real + self.imaginary * other.imaginary) / denom imag_part = (self.imaginary * other.real - self.real * other.imaginary) / denom return Complex(real_part, imag_part) def __eq__(self, other): return self.real == other.real and self.imaginary == other.imaginary def __str__(self): sign = "+" if self.imaginary >= 0 else "-" return f"{self.real}{sign}{abs(self.imaginary)}i" @staticmethod def get_object_count(): return Complex.__object_count ``` #### 2. 测试脚本 (`test_complex.py`) ```python from complex_class import Complex if __name__ == "__main__": c1 = Complex(3, 4) c2 = Complex.from_string("5+12i") print(f"Object Count: {Complex.get_object_count()}") print(f"c1: {c1}, Modulus: {c1.modulus():.2f}") print(f"c2: {c2}, Modulus: {c2.modulus():.2f}") sum_c = c1 + c2 diff_c = c1 - c2 prod_c = c1 * c2 quot_c = c1 / c2 print(f"Sum: {sum_c}") print(f"Difference: {diff_c}") print(f"Product: {prod_c}") print(f"Quotient: {quot_c:.2f}") ``` --- ### 总结 以上分别提供了 C++ 和 Python 的解决方案，均实现了复数类的核心功能，并将其分布于多个文件中以便于管理和测试。每种语言都充分利用了其特性来完成任务。