C++基础与类的构建：从基础到稳健类的打造

### C++基础与类的构建：从基础到稳健类的打造 #### 1. C++基础数据容器与运算符 在C++编程中，有一些重要的数据容器，它们在数据存储和处理方面发挥着关键作用： - **向量（Vectors）**：用于存储一系列相同类型的数据，支持动态增长。 - **列表（Lists）**：提供了高效的插入和删除操作。 - **映射（Maps，或字典）**：以键值对的形式存储数据，方便根据键快速查找值。 需要注意的是，在很多情况下，我们无需自己创建数据容器和对应的算法，利用现有的数据容器往往能更高效地完成任务。 C++中的作用域解析运算符 `::` 是一个重要的特性。与C和其他过程式语言不同，C++允许将成员函数定义为类的元素。为了明确这种关系，我们使用作用域解析运算符 `::`。例如： ```cpp double EuropeanOption::Price() const { if (optType == "C") { return CallPrice(); } else return PutPrice(); } ``` 在这个例子中，`Price()` 定价函数属于 `EuropeanOption` 期权类。 另外，关于析构函数，建议将所有析构函数声明为虚函数。虽然具体原因后续会详细讨论，但不这样做可能会导致内存问题，所以为了安全起见，我们应遵循这一原则。 #### 2. 其他编程范式在金融计算中的应用 除了面向对象编程范式，模块化编程技术在金融计算中也有广泛应用。下面以一些简单的利率计算为例进行说明。 我们创建了一系列用于利率计算的函数，包括： - 计算一笔资金的未来价值（每年支付一次、每年支付m次以及连续复利） - 普通年金的未来价值 - 简单的现值计算 - 一系列未来价值的现值 - 普通年金的现值 为了实现这些功能，我们通常创建两个文件：一个头文件包含函数声明，另一个文件包含具体的代码实现。以下是头文件 `SimpleBondPricing.hpp` 的内容： ```cpp // SimpleBondPricing.hpp // // Simple functions for interest rate calcuations. // // (C) Datasim Education BV 2006 // #ifndef SimpleBondPricing HPP #define SimpleBondPricing HPP #include <vector> using namespace std; namespace Chapter3CPPBook // Logical grouping of functions and others { // Handy shorthand synonyms typedef vector<double> Vector; // Recursive function to calculate power of a number. This // function calls itself, either directly or indirectly double power(double d, long n); // Future value of a sum of money invested today double FutureValue(double P0, long nPeriods, double r); // Future value of a sum of money invested today, m periods // per year. r is annual interest rate double FutureValue(double P0, long nPeriods, double r, long m); // Continuous compounding, i.e. limit as m -> INFINITY double FutureValueContinuous(double P0, long nPeriods, double r); // Future value of an ordinary annuity double OrdinaryAnnuity(double A, long nPeriods, double r); // Present Value double PresentValue(double Pn, long nPeriods, double r); // Present Value of a series of future values double PresentValue(const Vector& prices,long nPeriods,double r); // Present Value of an ordinary annuity double PresentValueOrdinaryAnnuity(double A,long nPer,double r); } #endif ``` 这里使用了 `namespace` 关键字对相关函数进行逻辑分组。要访问命名空间中的函数，可以显式使用命名空间名称，例如： ```cpp double fv2 = Chapter3CPPBook::FutureValue(P, nPeriods, r, freq); ``` 也可以使用 `using` 声明，例如： ```cpp using namespace Chapter3CPPBook; cout << "**Future with " << m << " periods: " << FutureValue(P0, nPeriods, r, m) << endl; ``` 使用命名空间的主要优点是可以减少与应用程序其他部分代码的命名冲突。 下面是一些具体函数的实现示例： - 计算资金未来价值的函数： ```cpp // Future value of a sum of money invested today double FutureValue(double P0, long nPeriods, double r) { double factor = 1.0 + r; return P0 * power(factor, nPeriods); } ``` 其中，`power()` 函数用于计算一个数的幂： ```cpp // Non-recursive function to calculate power of a number. double power(double d, long n) { if (n == 0) return 1.0; if (n == 1) return d; double result = d; for (long j = 1; j < n; j++) { result *= d; } return result; } ``` - 计算一系列未来价格现值的函数： ```cpp // Present Value of a series of future values double PresentValue(const Vector& prices,long nPeriods, double r) { // Number of periods MUST == size of the vector assert (nPeriods == prices.size()); double factor = 1.0 + r; double PV = 0.0; for (long t = 0; t < nPeriods; t++) { PV += prices[t] / power(factor, t+1); } return PV; } ``` 在这个函数中，向量的大小必须与周期数相同，否则 `assert()` 函数会被调用，程序将立即终止。不过，这只是为了帮助我们学习C++，后续会介绍如何通过异常处理机制来捕获和解决这类运行时错误。 以下是使用这些函数的一个示例： ```cpp // Present Value of a series of future values Vector futureValues(5); // For five years, calls constructor for (long j = 0; j < 4; j++) { // The first 4 years futureValues[j] = 100.0; // Vector has indexing [] } futureValues[4] = 1100.0; int nPeriods = 5; double r = 0.0625; cout << "**Present value, series: " << PresentValue(futureValues, nPeriods, r) << endl; ``` #### 3. 创建稳健类的重要性及相关概念 在C++编程中，创建更稳健和高效的类是非常重要的。我们需要解决一些与数据和对象安全相关的问题，主要包括： 1. 确保对象及其数据以安全的方式创建。 2. 安全地访问和使用对象，避免副作用。 3. 使用对象引用而不是对象副本。 4. 优化：使用静态对象和静态成员数据。 为了实现这些目标，我们需要掌握以下几个重要的C++概念： - **按值传递和按引用传递参数**：在函数调用时，参数可以按值传递或按引用传递。 - **函数重载**：允许定义多个具有相同名称的函数。 - **构造函数的更多知识**：构造函数在对象创建时起着重要作用。 - **非成员函数**：并非所有函数都必须是成员函数。 - **`const` 关键字及其对C++应用的影响**：`const` 关键字可以保证对象的常量性。 #### 4. 按值传递和按引用传递的区别 在C++中，函数可以接受零个或多个参数。参数的传递方式有按值传递和按引用传递两种。下面通过一个简单的例子来说明按值传递： ```cpp double Max(double x, double y) { if (x > y) return x; return y; } ``` 当调用这个函数时： ```cpp double d1 = 1.0; double d2 = - 34536.00; double result = Max(d1, d2); cout << "Maxvalue is " << result << endl; ``` 在 `Max()` 函数内部，使用的是 `d1` 和 `d2` 的副本，而不是它们本身。这种按值传递的方式对于内置类型比较常用。 但对于对象，按值传递可能会导致效率问题。例如，有一个包含固定大小数组的类 `SampleClass`： ```cpp class SampleClass { public: // For convenience only // This data created at compile time double contents[1000]; public: SampleClass(double d) { for (int i = 0; i < 1000; i++) { contents[i] = d; } } virtual ~SampleClass() { cout << "SampleClass instance being deleted\n"; } }; ``` 如果有一个全局函数 `Sum()` 用于计算 `SampleClass` 对象元素的总和，按值传递会创建对象的副本： ```cpp double Sum(SampleClass myClass) { double result = myClass.contents[0]; for (int i = 1; i < 1000; i++) { result += myClass.contents[i]; } return result; }; ``` 调用这个函数时： ```cpp SampleClass sc(1.0); double sum = Sum(sc); ``` 会创建 `sc` 的副本，这会带来额外的开销。为了避免这个问题，我们可以使用按引用传递： ```cpp double Sum2(SampleClass& myClass) { double result = myClass.contents[0]; for (int i = 1; i < 1000; i++) { result += myClass.contents[i]; } return result; }; ``` 在 `Sum2()` 函数中，直接使用对象的地址，而不是副本。不过，这样可能会导致副作用，例如在函数内部修改对象的值。 关于按值传递和按引用传递，有以下几点注意事项： - 对于内置类型，通常使用按值传递；对于对象和类实例，建议使用按引用传递。 - 尽量避免使用指针作为函数的输入参数，后续会详细讨论原因。 - 使用按引用传递时，只需在函数声明中将对象声明为引用，在主程序中可以像使用普通对象一样使用它。 下面是按值传递和按引用传递的流程对比： ```mermaid graph LR classDef startend fill:#F5EBFF,stroke:#BE8FED,stroke-width:2px; classDef process fill:#E5F6FF,stroke:#73A6FF,stroke-width:2px; classDef decision fill:#FFF6CC,stroke:#FFBC52,stroke-width:2px; A([开始]):::startend --> B(定义函数):::process B --> C{参数传递方式}:::decision C -->|按值传递| D(创建参数副本):::process C -->|按引用传递| E(使用参数地址):::process D --> F(函数内部操作副本):::process E --> G(函数内部操作原对象):::process F --> H(返回结果):::process G --> H H --> I([结束]):::startend ``` #### 5. 常量对象和只读成员函数 使用引用作为函数参数时，函数可能会修改输入参数。为了避免这种情况，我们可以将对象定义为常量引用，例如： ```cpp double Sum3(const SampleClass& myClass) { // N.B. not possible to modify myClass }; ``` 在 `Sum3()` 函数中，不能修改 `myClass` 对象，这样可以避免副作用。如果尝试修改，编译器会报错。 另外，对于成员函数，我们可以将其声明为只读（`const`）成员函数。以一个表示二维点的类 `Point` 为例： ```cpp class Point { private: void init(double xs, double ys); // Properties for x- and y-coordinates double x; double y; public: // Constructors and destructor Point(); // Default constructor Point(double xs, double ys); // Construct with coordinates Point(const Point& source); // Copy constructor virtual ~Point(); // Destructor // Selectors double X() const; // Return x double Y() const; // Return y // ... }; ``` 在这个类中，`X()` 和 `Y()` 函数被声明为常量成员函数，这意味着它们的函数体不能修改 `Point` 对象的私有成员数据。以下是这两个函数的具体实现： ```cpp double Point::X() const {// Return x return x; } double Point::Y() const {// Return y return y; } ``` 通过使用常量成员函数，客户端代码可以放心地使用这些函数，因为它们不会修改对象的值。而对于需要修改成员数据的函数，通常不能声明为 `const` 函数，例如： ```cpp // Modifiers void X(double NewX); // Set x void Y(double NewY); // Set y ``` 其实现如下： ```cpp // Modifiers void Point::X(double NewX) {// Set x x = NewX; } void Point::Y(double NewY) {// Set y y = NewY; } ``` 下面是一个使用 `Point` 类的示例： ```cpp Point p1(1.0, 3.14); // Read the coordinate onto the Console cout << "First coordinate: " << p1.X() << endl; cout << "Second coordinate: " << p1.Y() << endl; ``` 总结来说，通过合理使用常量对象和只读成员函数，可以提高代码的安全性和可靠性。在实际编程中，我们应该根据具体需求选择合适的参数传递方式和函数声明方式，以确保代码的高效性和稳定性。 ### C++基础与类的构建：从基础到稳健类的打造 #### 6. 利率计算函数总结与拓展 在前面介绍的利率计算函数中，涵盖了多种计算场景，下面将这些函数的数学公式和代码实现进行总结，并提出一些拓展思路。 | 计算类型 | 数学公式 | 代码函数 | | --- | --- | --- | | 资金未来价值（每年支付一次） | \(P_n = P_0(1 + r)^n\) | `double FutureValue(double P0, long nPeriods, double r)` | | 资金未来价值（每年支付m次） | \(P_n = P_0(1 + \frac{r}{m})^{mn}\) | `double FutureValue(double P0, long nPeriods, double r, long m)` | | 连续复利资金未来价值 | \(P_n = P_0e^{rn}\) | `double FutureValueContinuous(double P0, long nPeriods, double r)` | | 普通年金未来价值 | \(P_n = A\frac{(1 + r)^n - 1}{r}\) | `double OrdinaryAnnuity(double A, long nPeriods, double r)` | | 简单现值计算 | \(PV = P_0 = P_n\frac{1}{(1 + r)^n}\) | `double PresentValue(double Pn, long nPeriods, double r)` | | 一系列未来价值的现值 | \(PV = \sum_{t = 1}^{n}\frac{P_t}{(1 + r)^t}\) | `double PresentValue(const Vector& prices,long nPeriods,double r)` | | 普通年金现值 | \(PV = A\frac{1 - \frac{1}{(1 + r)^n}}{r}\) | `double PresentValueOrdinaryAnnuity(double A,long nPer,double r)` | 除了上述已实现的函数，还可以添加一些新的函数到命名空间中。例如，实现连续复利利率与每年m次复利利率之间的转换： ```cpp // 连续复利利率转换为每年m次复利利率 double ContinuousToMCompounding(double rc, long m) { return m * (exp(rc / m) - 1); } // 每年m次复利利率转换为连续复利利率 double MToContinuousCompounding(double rm, long m) { return m * log(1 + rm / m); } ``` #### 7. 函数重载的应用 函数重载是C++中一个非常有用的特性，它允许我们定义多个具有相同名称但参数列表不同的函数。在前面的利率计算函数中，`FutureValue` 函数就使用了函数重载： ```cpp // 资金未来价值（每年支付一次） double FutureValue(double P0, long nPeriods, double r) { double factor = 1.0 + r; return P0 * power(factor, nPeriods); } // 资金未来价值（每年支付m次） double FutureValue(double P0, long nPeriods, double r, long m) { double factor = 1.0 + r / m; return P0 * power(factor, nPeriods * m); } ``` 编译器会根据调用函数时提供的参数类型和数量来决定调用哪个重载函数。函数重载的优点在于提高了代码的可读性和可维护性，让开发者可以使用相同的名称来处理不同类型的操作。 #### 8. 构造函数的深入理解 构造函数在对象创建时起着至关重要的作用。它负责初始化对象的成员变量，确保对象在创建后处于一个有效的状态。以 `Point` 类为例，它有多个构造函数： ```cpp class Point { private: void init(double xs, double ys); // Properties for x- and y-coordinates double x; double y; public: // 无参构造函数 Point(); // 带参数构造函数 Point(double xs, double ys); // 拷贝构造函数 Point(const Point& source); // 析构函数 virtual ~Point(); // ... }; // 无参构造函数实现 Point::Point() { init(0.0, 0.0); } // 带参数构造函数实现 Point::Point(double xs, double ys) { init(xs, ys); } // 拷贝构造函数实现 Point::Point(const Point& source) { init(source.x, source.y); } // 初始化函数实现 void Point::init(double xs, double ys) { x = xs; y = ys; } ``` - **无参构造函数**：当创建对象时没有提供参数，会调用无参构造函数。它通常将对象的成员变量初始化为默认值。 - **带参数构造函数**：允许在创建对象时提供初始值，用于定制对象的初始状态。 - **拷贝构造函数**：用于创建一个新对象，该对象是另一个同类型对象的副本。 #### 9. 非成员函数的作用 并非所有函数都必须是成员函数。非成员函数可以独立于类存在，它们可以操作类的对象，但不需要访问类的私有成员。在前面的利率计算函数中，所有函数都是非成员函数，它们通过命名空间进行逻辑分组。非成员函数的优点在于提高了代码的灵活性和可复用性，不同的类可以共享这些函数。 例如，`Sum` 系列函数可以作为非成员函数来计算对象元素的总和： ```cpp // 按值传递计算总和 double Sum(SampleClass myClass) { double result = myClass.contents[0]; for (int i = 1; i < 1000; i++) { result += myClass.contents[i]; } return result; } // 按引用传递计算总和 double Sum2(SampleClass& myClass) { double result = myClass.contents[0]; for (int i = 1; i < 1000; i++) { result += myClass.contents[i]; } return result; } // 常量引用传递计算总和 double Sum3(const SampleClass& myClass) { double result = myClass.contents[0]; for (int i = 1; i < 1000; i++) { result += myClass.contents[i]; } return result; } ``` #### 10. 总结与实践建议 通过对C++基础数据容器、运算符、编程范式、参数传递方式、常量对象和成员函数等方面的学习，我们可以构建出更稳健和高效的类。以下是一些实践建议： - **数据容器选择**：根据具体需求选择合适的数据容器，如向量适用于动态数组，列表适用于频繁插入和删除操作，映射适用于键值对存储。 - **参数传递**：对于内置类型，使用按值传递；对于对象和类实例，优先使用按引用传递，必要时使用常量引用避免副作用。 - **函数设计**：合理使用函数重载和非成员函数，提高代码的可读性和可维护性。 - **构造函数使用**：根据对象的初始化需求，设计合适的构造函数，确保对象在创建后处于有效状态。 - **常量性保证**：使用 `const` 关键字来保证对象的常量性，提高代码的安全性。 在实际编程中，不断实践和总结经验，才能更好地掌握C++编程技巧，打造出高质量的代码。 下面是一个简单的实践流程，帮助你巩固所学知识： ```mermaid graph LR classDef startend fill:#F5EBFF,stroke:#BE8FED,stroke-width:2px; classDef process fill:#E5F6FF,stroke:#73A6FF,stroke-width:2px; classDef decision fill:#FFF6CC,stroke:#FFBC52,stroke-width:2px; A([开始]):::startend --> B(选择一个编程场景):::process B --> C(设计类和函数):::process C --> D{是否需要数据容器}:::decision D -->|是| E(选择合适的数据容器):::process D -->|否| F(继续设计):::process E --> F F --> G{参数传递方式}:::decision G -->|按值传递| H(使用按值传递设计函数):::process G -->|按引用传递| I(使用按引用传递设计函数):::process H --> J(设计构造函数和成员函数):::process I --> J J --> K(使用const关键字保证常量性):::process K --> L(编写测试代码):::process L --> M(调试和优化代码):::process M --> N([结束]):::startend ``` 通过以上流程，你可以逐步构建出一个完整的C++程序，同时运用所学的各种知识来提高代码的质量。