简介：C++是一门重要的编程语言，广泛应用于多个领域。2008年版的《C++入门经典》为初学者提供了学习C++的全面平台，涵盖了从基础语法到面向对象编程的核心概念。本书不仅包含基础语法、控制结构、函数、类和对象、模板、异常处理等基础知识点，还通过习题实践加深了对这些概念的理解。本书的习题设计旨在帮助初学者熟悉编程技巧，并将理论知识转化为实际编程技能。通过解答这些习题，学习者可以提高编程能力，为深入学习C++打下坚实基础。
1. C++基础语法学习与应用
C++是一种静态类型、编译式、通用的编程语言，它支持多种编程范式，包括过程化、面向对象和泛型编程。掌握其基础语法是开发C++程序的关键起点。本章内容将以简洁明了的方式引导初学者入门C++编程。
环境搭建与第一个程序
在开始编写C++代码之前，我们需要设置一个开发环境。推荐使用支持C++11及以上标准的编译器，如GCC、Clang或者Microsoft Visual C++。一个简单的C++程序通常包含一个主函数 main() ，它是程序的入口点。
#include <iostream>
int main() {
std::cout << "Hello, World!" << std::endl;
return 0;
}
以上程序中， #include <iostream> 是预处理指令，用于包含标准输入输出流库。 std::cout 是输出流对象， std::endl 是插入操作符，用于在输出内容后添加换行符并刷新输出缓冲区。 main() 函数的返回值 0 表示程序成功执行。
基础语法概述
C++的基础语法包括数据类型、变量、运算符、控制流语句等。数据类型定义了变量或函数可以存储的数据种类；变量是存储数据的容器；运算符用于执行各种操作；控制流语句则用于控制程序的执行流程。
在下一章中，我们将详细讨论C++的控制结构，包括条件控制和循环控制，这些是构建复杂逻辑所不可或缺的工具。掌握这些基础之后，你将能够编写出更加复杂的程序。
2. C++控制结构练习
C++编程不仅仅是语法的堆砌，更重要的是逻辑的构建。控制结构是实现复杂逻辑的关键，本章将深入探讨C++中的条件控制结构与循环控制结构，并通过具体实例进行练习，使你能够灵活运用这些结构来编写出更加高效、优雅的代码。
2.1 条件控制结构深入分析
2.1.1 if语句的多种变体及其使用场景
在C++中，if语句是条件判断最基本的元素，它拥有多种变体，包括if-else、else if、嵌套if等，这些变体可以应对各种复杂的条件逻辑。
#include <iostream>
using namespace std;
int main() {
int num = 5;
if (num > 0) {
cout << "正数" << endl;
} else if (num < 0) {
cout << "负数" << endl;
} else {
cout << "零" << endl;
}
return 0;
}
在这段代码中，我们首先定义了一个整型变量 num 并赋值为5，然后通过 if-else if-else 结构判断 num 的值，并输出相对应的信息。这种结构适用于在多个条件之间进行选择，选择第一个满足条件的分支执行，并且当条件较多时，代码的可读性较好。
2.1.2 switch-case结构及其与if-else的比较
switch-case 结构提供了一种不同于 if-else 的条件判断方式，它主要用来判断一个变量或表达式是否与一系列的常量值相匹配。
#include <iostream>
using namespace std;
int main() {
char grade = 'B';
switch(grade) {
case 'A':
cout << "优秀" << endl;
break;
case 'B':
case 'C':
cout << "良好" << endl;
break;
case 'D':
cout << "及格" << endl;
break;
case 'F':
cout << "不及格" << endl;
break;
default:
cout << "无效的成绩" << endl;
}
return 0;
}
在这段示例代码中，使用了 switch 语句根据 grade 变量的值来输出不同的评语。 switch 语句的优点在于，代码结构清晰且执行效率较高，特别是当需要匹配多个具体值时比 if-else 链更加直观。
2.2 循环结构的灵活运用
2.2.1 for、while和do-while循环的特性与选择
C++中的循环结构包括 for 循环、 while 循环和 do-while 循环，它们各有特点，适用于不同的场景。
#include <iostream>
using namespace std;
int main() {
// for 循环示例
for (int i = 0; i < 10; i++) {
cout << i << " ";
}
cout << endl;
// while 循环示例
int j = 0;
while (j < 10) {
cout << j << " ";
j++;
}
cout << endl;
// do-while 循环示例
int k = 0;
do {
cout << k << " ";
k++;
} while (k < 10);
cout << endl;
return 0;
}
在这段代码中，我们展示了三种循环结构的基本用法。 for 循环适用于初始化、条件判断和迭代在一处进行的场景； while 循环适用于初始条件在循环体外，需要在每次迭代前检查条件的场景； do-while 循环则确保了循环体至少执行一次。
2.2.2 循环的嵌套技巧及其在算法中的应用
循环的嵌套允许我们处理多维数据或复杂的逻辑，是解决实际问题中不可或缺的技能。
#include <iostream>
using namespace std;
int main() {
int size = 3;
int matrix[size][size]; // 创建一个3x3的矩阵
// 初始化矩阵
for (int i = 0; i < size; i++) {
for (int j = 0; j < size; j++) {
matrix[i][j] = i * size + j + 1;
}
}
// 输出矩阵
for (int i = 0; i < size; i++) {
for (int j = 0; j < size; j++) {
cout << matrix[i][j] << " ";
}
cout << endl;
}
return 0;
}
在这个例子中，我们创建了一个3x3的矩阵，并通过嵌套的 for 循环来初始化和打印矩阵。嵌套循环特别适用于处理数据的行和列，如二维数组操作，或者图形学中像素处理等。
练习这些控制结构的代码示例和实际应用，将帮助你更好地掌握C++程序的逻辑构建能力。通过不同的例子，你将学会在什么情况下选择最合适的控制结构来达到编程目的。
3. C++函数编程与调用
3.1 函数的定义与声明
3.1.1 函数原型的作用与重要性
在C++中，函数是执行特定任务的代码块。在编写大型程序时，将代码分解为函数可以提高可读性和可维护性。函数的定义和声明是函数编程的基础，而函数原型则是函数声明的重要组成部分。函数原型描述了函数的名称、返回类型以及参数列表的类型，但不包括函数体。在程序中调用函数之前，必须先提供函数原型。这样做的好处是编译器可以在编译时检查函数调用的正确性，确保传递给函数的参数类型和数量与声明一致。
// 函数原型示例
int add(int, int); // 声明一个返回int类型，接受两个int参数的函数
函数原型通常放在头文件中，以便在需要调用该函数的不同源文件之间共享。头文件在使用时应包含在源文件中，如 #include "add.h" 。
3.1.2 默认参数与函数重载的规则
默认参数允许函数调用时不必为所有参数提供值。如果在调用时省略了某个参数，函数将使用默认值。使用默认参数时需注意函数声明的位置，如果在多个文件中声明同一个函数，则在头文件中的声明必须包括默认参数。
// 使用默认参数的函数声明
void display(int width = 20, int height = 10); // 默认宽度和高度
函数重载允许存在多个同名函数，只要它们的参数列表不同即可。编译器根据参数类型、数量或顺序来区分不同的函数版本。函数重载在编写具有不同功能但名称相同的函数时非常有用。
// 函数重载示例
void print(int value); // 打印整数
void print(const std::string& value); // 打印字符串
需要注意的是，函数重载不考虑函数返回类型，仅根据参数列表来区分不同的函数版本。
3.2 参数传递机制
3.2.1 值传递、引用传递与指针传递的区别
在C++中，函数参数可以通过值传递、引用传递或指针传递来传递。这三种方式在参数传递上有本质的区别。
- 值传递：传递参数的一个副本到函数中。在函数内部对参数的修改不会影响原始数据。
- 引用传递：传递参数的引用，使得函数内部可以直接访问和修改原始数据。
- 指针传递：传递参数的内存地址，函数通过这个地址可以读取或修改原始数据。
引用传递和指针传递都可以修改原始数据，但引用传递的语法更为直观且不易出错。引用传递通常用于函数需要修改传入参数的情况，而指针传递则在需要修改指针本身或传递大量数据时更为常见。
3.2.2 参数传递的效率考量
参数传递机制不仅影响代码的行为，还可能影响程序的性能。值传递是最直接且安全的方式，但如果传递大型对象，其性能开销可能很大。引用传递和指针传递避免了复制大型对象的需要，但引用传递通常更为简洁和安全。
在选择参数传递机制时，应权衡代码的可读性、安全性以及性能需求。例如，在需要保持函数接口简洁性的同时，减少不必要的复制，可以优先考虑引用传递。
3.3 函数的高级特性
3.3.1 函数模板的原理与应用
函数模板允许编写与数据类型无关的通用代码。通过定义函数模板，可以创建多个功能相同但操作的数据类型不同的函数实例。
函数模板使用类型参数化，当函数被调用时，编译器根据传入的参数类型生成对应的函数代码。这使得函数模板可以应用于不同的数据类型，具有很高的灵活性。
// 函数模板示例
template <typename T>
T max(T a, T b) {
return (a > b) ? a : b;
}
在使用函数模板时，无需显式指定类型，编译器会根据上下文自动推导类型，也可以显式指定类型来调用函数模板。
3.3.2 递归函数的实现与优化
递归函数是通过函数自我调用来解决问题的函数。递归函数通常具有两个基本要素：基本情况（或终止条件）和递归步骤。在递归步骤中，函数调用自身来解决问题的一部分。
递归函数编写起来简洁直观，但在某些情况下可能导致效率低下或栈溢出错误。为了提高递归函数的性能，可以采用一些优化手段，如尾递归优化、记忆化递归等。
// 递归函数示例：计算阶乘
int factorial(int n) {
if (n <= 1) return 1; // 基本情况
return n * factorial(n - 1); // 递归步骤
}
在C++中，递归函数的调用需要消耗栈空间，特别是当递归深度很大时。因此，在设计递归算法时，应尽量避免不必要的递归调用，并考虑使用迭代或其他算法代替递归。
为了方便读者理解，下面是一个函数模板应用的示例代码：
#include <iostream>
#include <string>
// 函数模板定义
template <typename T>
T maximum(const T& a, const T& b) {
return (a > b) ? a : b;
}
int main() {
// 使用函数模板
std::cout << "Max between 4 and 7 is " << maximum(4, 7) << std::endl;
std::cout << "Max between 3.0 and 5.4 is " << maximum(3.0, 5.4) << std::endl;
std::cout << "Max between 'A' and 'Z' is " << maximum('A', 'Z') << std::endl;
return 0;
}
输出结果：
Max between 4 and 7 is 7
Max between 3.0 and 5.4 is 5.4
Max between 'A' and 'Z' is Z
通过示例代码，可以清楚地看到函数模板如何应用于不同类型的数据。函数模板的优势在于减少了代码的重复，同时保持了代码的灵活性和可重用性。
总结这一章节的内容，我们已经详细探讨了C++中函数的定义与声明，参数传递的不同方式以及它们的效率考量，以及函数模板的应用和递归函数的实现与优化。掌握这些知识对编写高效且可读性强的C++代码至关重要。在下一章节中，我们将深入探讨面向对象编程中的类与对象，继续展开C++编程的核心内容。
4. 面向对象编程：类与对象
4.1 类与对象的概念
4.1.1 类的定义及其与对象的关系
在C++中，类是面向对象编程的基础，它是一种用户定义的数据类型，可以封装数据和操作数据的方法。一个类可以包含多种类型的成员，比如变量、常量、函数和嵌套类等。类定义了一组对象共享的属性和行为，是创建对象的蓝图。
对象是类的实例，每个对象都拥有类中定义的属性和方法。当我们谈论“创建一个对象”时，实质上是根据类定义在内存中分配了一块空间，并且根据类定义初始化了该对象的属性，同时也可以调用类中定义的方法。
让我们以一个简单的例子来说明类与对象的关系：
class Car {
public:
void startEngine() {
// 启动引擎的逻辑
std::cout << "Engine started!\n";
}
void stopEngine() {
// 停止引擎的逻辑
std::cout << "Engine stopped.\n";
}
private:
std::string model; // 车型
int year; // 制造年份
};
int main() {
Car myCar; // 创建了一个Car类的对象
myCar.startEngine(); // 调用了对象的方法
return 0;
}
在上述代码中， Car 是一个类，它定义了启动和停止引擎的行为。 myCar 是 Car 类的一个对象，当我们调用 myCar.startEngine() 时，实际上是在告诉这个对象开始执行 Car 类中定义的 startEngine 方法。
4.1.2 访问控制与封装的实现
访问控制是面向对象编程中实现封装的关键。C++提供了三种访问控制级别：public、protected和private。这些访问说明符决定了类的成员能否被外部代码访问。
-
public成员可以在任何地方被访问。 -
protected成员可以被派生类访问。 -
private成员只能被类的内部成员函数访问。
封装是指将数据（或状态）和操作数据的代码捆绑在一起形成一个对象，并对对象的实现细节进行隐藏。这通常通过将数据成员设为 private 和提供 public 成员函数来实现，后者被用来访问和修改 private 成员变量。
下面是一个带有访问控制的类定义示例：
class BankAccount {
private:
double balance; // 私有成员，外部无法直接访问
public:
// 构造函数
BankAccount(double initialBalance) : balance(initialBalance) {}
// deposit函数公有，可以被任何对象调用
void deposit(double amount) {
if (amount > 0) balance += amount;
}
// withdraw函数公有，可以被任何对象调用
bool withdraw(double amount) {
if (amount <= balance) {
balance -= amount;
return true;
} else {
return false;
}
}
// 获取余额，外部无法直接访问，但可以通过公有方法获取
double getBalance() const {
return balance;
}
};
在此例中， BankAccount 类的 balance 成员是私有的，不能直接被外部访问。用户必须通过 deposit 、 withdraw 和 getBalance 函数来操作 balance 。这样就实现了封装，隐藏了对象的内部状态，只能通过对象提供的接口进行操作。
封装有助于维护性，因为数据的表示可以更改，只要公共接口保持不变，使用该类的代码就无需修改。同时，封装还增强了安全性，因为可以禁止对对象内部状态的不正确修改。
4.2 构造函数和析构函数
4.2.1 构造函数的不同类型及其初始化列表
构造函数是一种特殊的成员函数，用于创建对象时初始化对象的成员变量。构造函数的名字与类名相同，并且它没有返回类型。C++允许定义多种构造函数，这被称为构造函数重载。
初始化列表在构造函数定义中用来初始化类的成员变量。使用初始化列表比在构造函数体内赋值更高效，因为某些情况下可以省去复制构造函数的调用。
构造函数的主要类型有：
- 无参构造函数 ：不带任何参数的构造函数，通常用于提供默认初始化。
- 带参构造函数 ：带参数的构造函数，用于在创建对象时提供自定义的初始值。
- 拷贝构造函数 ：带有一个以当前类类型的常量引用作为参数的构造函数，用于创建一个新对象作为现有对象的副本。
- 移动构造函数 （C++11及以上）：接收一个右值引用，用于实现对象的移动语义，避免不必要的深拷贝。
下面是一个带有初始化列表的构造函数示例：
class Complex {
private:
double real;
double imag;
public:
// 带参数的构造函数
Complex(double r, double i) : real(r), imag(i) {
// 在这里可以添加其他逻辑
}
// 成员函数，用于打印复数
void print() {
std::cout << real << " + " << imag << "i\n";
}
};
在这个例子中， Complex 类定义了一个带参构造函数，并使用初始化列表来初始化 real 和 imag 成员变量。这种方式比在构造函数体内部赋值更简洁、更高效。
4.2.2 析构函数的作用与自动调用机制
析构函数也是一个特殊的成员函数，它在对象生命周期结束时被自动调用，用于执行清理工作，例如释放分配的资源。析构函数在C++中也是唯一一个不能有参数的函数，且其名称是在类名前加上一个波浪号（~）。
析构函数的自动调用机制确保对象在离开其作用域或动态分配的内存被释放时，适当的析构函数能够被自动执行。对于自动存储期对象，析构函数在对象生命周期结束时被调用；对于动态分配的对象，析构函数在使用 delete 运算符释放对象时被调用。
下面是一个带有析构函数的类定义示例：
class MyClass {
private:
char* data;
public:
MyClass(int size) {
data = new char[size]; // 动态分配内存
}
~MyClass() {
delete[] data; // 释放内存
}
};
在这个例子中， MyClass 类在构造函数中分配了内存，并在析构函数中释放了内存。析构函数的存在确保了内存资源被正确释放，防止内存泄漏。
4.3 继承与多态
4.3.1 继承的实现与派生类的特性
继承是面向对象编程的一个核心概念，允许创建类的层次结构。通过继承，派生类可以复用基类的属性和方法。派生类也称为子类或子类，基类也称为超类或父类。
在C++中，派生类继承了基类的成员变量和成员函数（除了构造函数和析构函数），并且可以添加新的成员变量和成员函数。继承可以是单一继承（只有一个基类）或多重继承（多个基类）。
继承的一般形式为：
class BaseClass {
// 基类成员
};
class DerivedClass : public BaseClass {
// 派生类成员
};
这里， DerivedClass 从 BaseClass 继承。关键字 public 指定了继承类型，它决定了基类成员在派生类中的访问权限。
派生类继承的特性包括：
- 访问继承 ：派生类可以访问基类中的公共（public）和保护（protected）成员。
- 多态继承 ：派生类可以覆盖基类中的虚拟函数，实现多态。
- 接口继承 ：派生类至少继承基类的接口（即函数声明）。
4.3.2 虚函数与多态的实现原理
多态允许使用基类的引用来调用派生类的对象，这是面向对象编程的另一个关键特性。C++通过在基类中声明虚拟函数来实现多态。
当基类中的函数被声明为虚拟时，这意味着派生类可以提供该函数的一个特定实现，称为覆盖。通过基类的引用或指针调用虚拟函数时，实际上调用的是与对象类型相对应的函数版本，这个过程称为动态绑定。
虚拟函数的声明如下：
class Base {
public:
virtual void doSomething() {
std::cout << "Base::doSomething\n";
}
};
class Derived : public Base {
public:
virtual void doSomething() override {
std::cout << "Derived::doSomething\n";
}
};
在这个例子中， Base 类有一个虚拟函数 doSomething ， Derived 类覆盖了这个函数。当通过基类指针或引用调用 doSomething 时，会根据实际的对象类型（ Base 或 Derived ）来决定调用哪个版本的 doSomething 。
多态的实现依赖于虚函数表（vtable），每个包含虚拟函数的类都有一个vtable，它是一个函数指针数组。每当创建一个对象时，其虚表指针（vptr）会被设置指向该类的vtable。当通过一个虚函数被调用时，实际上是在通过vptr查表找到正确的函数地址来调用。
实现多态不仅增加了程序的灵活性，还使得设计更加模块化。例如，我们可以定义一个处理基类引用的函数，这个函数可以接受任何派生类的对象，并且根据对象的实际类型调用相应的函数。这就是所谓的开闭原则，即“对扩展开放，对修改关闭”。
在本章节中，我们探索了类与对象的定义、构造函数和析构函数的原理以及继承与多态的实现。这些都是C++面向对象编程中非常重要的概念，了解并掌握这些知识对于构建高效、可维护的C++程序至关重要。
5. C++模板使用与泛型编程
模板是C++提供的一种编程泛型机制，它允许程序员编写与数据类型无关的代码，从而实现代码的重用和类型安全。在本章中，我们将详细探讨模板的概念、函数模板、类模板的使用，以及如何利用模板实现泛型编程。
5.1 模板的基础知识
模板是C++语言中一个复杂且功能强大的特性，允许用户编写独立于特定数据类型的代码。通过模板，可以创建函数或类，它们能够适应不同的数据类型，而无需为每种数据类型编写重复的代码。
5.1.1 模板的定义与实例化
模板的定义以关键字 template 开始，后跟一个或多个模板参数列表，这些参数在随后的定义中可以被引用。最简单的模板定义如下：
template <typename T>
T max(T a, T b) {
return (a > b) ? a : b;
}
在上面的示例中， typename T 是一个模板参数，表示一个占位符，用于之后被具体的数据类型替代。 max 函数的目的是比较两个值，并返回较大的一个。
实例化模板时，编译器会自动替换模板参数列表中的类型参数，创建与具体类型相匹配的函数或类。例如：
int main() {
int i = 42;
double d = 3.14;
std::cout << max(i, d) << '\n'; // 自动实例化为max<int>和max<double>
return 0;
}
5.1.2 类型参数化与代码复用
模板的一个重要优点是类型参数化，这允许函数或类对不同的数据类型具有通用性。这样，相同的逻辑可以适用于多种数据类型，从而增强代码复用性。
例如，标准模板库(STL)中的容器如 vector 和 map 就是使用模板参数化的结果，可以存储任何类型的数据而无需修改源代码。
std::vector<int> vec_ints; // 存储int类型数据的vector
std::vector<std::string> vec_strings; // 存储string类型数据的vector
5.2 函数模板详解
函数模板允许开发者编写不特定于任何具体数据类型的函数。函数模板能够根据传递给它的参数类型自动推导出合适的实例。
5.2.1 函数模板的声明与定义
函数模板的声明与定义和普通函数很相似，但模板声明部分是必须的。例如，我们定义一个交换两个值的模板函数：
template <typename T>
void swap(T& a, T& b) {
T temp = a;
a = b;
b = temp;
}
该函数模板可以接受任意类型的参数，并交换它们的值。
5.2.2 模板函数的重载与特化
函数模板可以被重载，也就是说，可以创建多个同名但模板参数列表不同的函数模板，编译器会选择最合适的模板进行实例化。此外，函数模板还可以被特化，即为特定类型提供特定实现。
// 重载的模板函数
template <typename T>
T max(T a, T b) {
return (a > b) ? a : b;
}
// 特化的模板函数，仅当类型为T为const char*时使用
template <>
const char* max(const char* a, const char* b) {
return strcmp(a, b) > 0 ? a : b;
}
5.3 类模板的应用
类模板是模板概念在类定义中的应用，它允许创建可以存储任意类型数据的类。类模板是C++泛型编程的核心组成部分，为开发者提供了强大的抽象和代码复用能力。
5.3.1 类模板的声明与实现
类模板的声明和实现与函数模板类似，但更为复杂。例如，创建一个简单的泛型栈类模板：
template <typename T>
class Stack {
private:
std::vector<T> elements;
public:
void push(const T& element) {
elements.push_back(element);
}
void pop() {
if (!elements.empty()) {
elements.pop_back();
}
}
const T& top() const {
if (!elements.empty()) {
return elements.back();
}
}
};
该栈类模板使用 std::vector 来存储元素，并提供了基础的栈操作。
5.3.2 类模板与继承、多态的结合使用
类模板可以与继承、多态等面向对象特性结合，创建更加灵活和强大的类结构。例如，可以创建一个接口类模板，并使用继承来扩展功能：
template <typename T>
class Container {
public:
virtual ~Container() {}
virtual void add(const T& item) = 0;
};
class StringContainer : public Container<std::string> {
public:
void add(const std::string& item) override {
// 实现字符串的添加逻辑
}
};
在这个例子中， Container 是一个接口类模板， StringContainer 是一个派生类模板，它实现了接口中的方法，并具有特定类型 std::string 的数据处理能力。
通过以上内容，我们可以看到C++模板的强大之处以及如何利用它实现泛型编程。模板为我们提供了一种高效和类型安全的方法来编写抽象代码，它们是C++标准库强大的基础，也是任何高级C++开发者不可或缺的工具。
6. C++异常处理机制
异常处理是程序设计中的一个重要概念，它允许程序在遇到错误或异常情况时，能够优雅地恢复或终止运行，而不是突然崩溃。在C++中，异常处理提供了一种机制来处理运行时错误，如除以零、内存不足等，以及程序员自定义的异常。
6.1 异常处理的基本概念
异常处理的关键组成部分包括 try 、 catch 、 throw 和 finally 块。 throw 语句用于抛出异常，而 try 块包含了可能抛出异常的代码。 catch 块则捕获并处理异常，而 finally 块包含了无论是否发生异常都需要执行的代码。
6.1.1 抛出与捕获异常的机制
在C++中，异常可以是任何类型的对象。当发生一个错误时，可以使用 throw 关键字抛出一个异常对象。例如：
throw std::runtime_error("An error has occurred");
这段代码抛出了一个 std::runtime_error 类型的异常对象。异常被抛出后，程序会寻找一个能处理这种异常的 catch 块。
try 块将可能抛出异常的代码包裹起来，紧随其后的是 catch 块，用于捕获并处理异常。例如：
try {
// code that may throw an exception
} catch (const std::exception& e) {
// handle the exception
std::cerr << e.what() << std::endl;
}
这里的 catch 块捕获了 std::exception 类型的异常。如果异常是 std::runtime_error 的派生类，则该 catch 块同样能够捕获它，因为 std::runtime_error 派生于 std::exception 。
6.1.2 标准异常类与自定义异常类
C++标准库提供了多种异常类，它们都直接或间接地继承自 std::exception 。其中， std::runtime_error 和 std::logic_error 是最常用的两个基类，用于派生其他异常类型。
程序员还可以定义自己的异常类型，通常从 std::exception 派生：
class MyCustomException : public std::exception {
public:
const char* what() const noexcept override {
return "My custom exception has occurred";
}
};
在上面的例子中， MyCustomException 类定义了一个自定义异常类型，通过 what() 函数返回异常信息。
6.2 异常处理的高级应用
异常处理机制不仅可以用于基础错误处理，还可以用于管理资源、控制程序流程等高级场景。
6.2.1 异常规格说明的使用与限制
C++11引入了 noexcept 说明符，用于告诉编译器某个函数不会抛出异常。这有助于优化性能，因为它允许编译器生成更好的代码。
void myFunction() noexcept {
// function implementation
}
如果 myFunction() 内部抛出了异常，程序将会调用 std::terminate() 立即终止，因为它违反了 noexcept 的承诺。
6.2.2 构造函数和析构函数中的异常处理
在构造函数和析构函数中使用异常需要谨慎，因为如果异常在构造函数中被抛出，则对象可能不完整或未被正确构造。析构函数如果抛出异常，同时在同一个作用域内有其他异常未被捕获，则程序将调用 std::terminate() 。
class MyClass {
public:
MyClass() {
// initialization code
}
~MyClass() {
// cleanup code
}
};
在上面的类定义中，我们需要确保析构函数中的代码不会抛出异常，或者如果可能抛出异常，则在抛出之前处理掉。如果需要在析构函数中处理异常，可以这样做：
~MyClass() {
try {
// cleanup code that might throw
} catch (...) {
// handle or log the exception
}
}
在构造函数中抛出异常时，已构造的对象会被自动销毁，其析构函数会被调用。
异常处理是C++程序设计中不可或缺的一部分，它使得程序员能够更加优雅地处理运行时错误和异常情况。在这一章中，我们从异常处理的基础概念开始学习，然后深入了解了在构造函数和析构函数中处理异常的高级技巧。理解并正确使用这些概念，可以让C++程序更加健壮和可靠。
7. C++实际应用编程：数组、字符串、文件IO
7.1 数组与字符串处理
7.1.1 动态数组的使用与管理
动态数组是C++中常用的数据结构，它允许在程序运行时分配和释放内存。相比静态数组，动态数组提供了更大的灵活性。我们可以使用指针和 new 、 delete 操作符来管理动态数组。
// 动态分配数组
int* dynamicArray = new int[10]; // 分配10个int的空间
// 使用数组...
// ...
// 释放数组
delete[] dynamicArray; // 释放之前分配的内存
在使用动态数组时，要特别注意内存泄漏的问题。确保每次使用 new 分配内存后，最终都要使用 delete[] 进行释放。
7.1.2 C++标准模板库中的字符串类
C++标准模板库（STL）中包含了一个 string 类，它提供了一个更安全、易用的方式来处理字符串。 string 类自动管理内存，我们无需担心内存泄漏的问题。
#include <string>
// 创建string对象
std::string str = "Hello, World!";
// 进行字符串操作...
// ...
// 使用string类的便利功能，如连接字符串
str += " String manipulation is easy!";
string 类还支持大量的成员函数，用于执行各种字符串操作，如查找、替换、比较等。
7.2 文件输入输出（IO）
7.2.1 文件流类的使用与操作
文件IO是进行数据持久化存储的重要手段。C++通过fstream库中的 ifstream 和 ofstream 类来处理文件的读写操作。
#include <fstream>
#include <iostream>
// 使用ifstream来读取文件
std::ifstream inFile("input.txt");
if (inFile.is_open()) {
std::string line;
while (getline(inFile, line)) {
std::cout << line << std::endl;
}
inFile.close();
} else {
std::cout << "Unable to open file" << std::endl;
}
// 使用ofstream来写入文件
std::ofstream outFile("output.txt");
if (outFile.is_open()) {
outFile << "Writing to a file is easy!" << std::endl;
outFile.close();
} else {
std::cout << "Unable to open file" << std::endl;
}
在进行文件操作时，总是检查文件是否成功打开是非常重要的。操作完成后，确保调用 close() 方法来关闭文件流。
7.2.2 文件读写实践与错误处理
在处理文件IO时，错误处理是不可或缺的环节。我们可以使用C++的异常处理机制来处理这些错误情况。
#include <fstream>
#include <iostream>
#include <stdexcept>
try {
std::ofstream outFile("output.txt");
if (!outFile) {
throw std::runtime_error("Unable to open output file.");
}
outFile << "Writing to a file is easy!" << std::endl;
outFile.close();
} catch (const std::exception& e) {
std::cerr << "An error occurred: " << e.what() << std::endl;
// 处理其他异常...
}
在上述代码中，我们使用 try 和 catch 块来捕获并处理可能发生的异常。使用异常处理机制可以避免程序在遇到错误时突然崩溃。
7.3 综合实践项目
7.3.1 构建简单的文本编辑器
创建一个简单的文本编辑器是一个很好的练习，可以帮助我们综合运用数组、字符串、文件IO的知识。这个项目可以简单到提供文本的打开、编辑和保存功能。
7.3.2 文件管理系统的设计与实现
另一个更高级的项目是设计并实现一个文件管理系统。这将需要使用到文件的搜索、复制、移动、删除等操作，以及可能的目录结构管理。
// 示例代码：搜索目录下的文件
#include <filesystem>
namespace fs = std::filesystem;
void searchFiles(const fs::path& path) {
for (const auto& entry : fs::recursive_directory_iterator(path)) {
if (fs::is_regular_file(entry)) {
std::cout << "Found file: " << entry.path() << '\n';
}
}
}
以上代码段使用了C++17的 <filesystem> 库来递归搜索目录中的文件。
在实际应用编程中，不断练习上述技能可以帮助我们加深理解，并提高解决实际问题的能力。
简介：C++是一门重要的编程语言，广泛应用于多个领域。2008年版的《C++入门经典》为初学者提供了学习C++的全面平台，涵盖了从基础语法到面向对象编程的核心概念。本书不仅包含基础语法、控制结构、函数、类和对象、模板、异常处理等基础知识点，还通过习题实践加深了对这些概念的理解。本书的习题设计旨在帮助初学者熟悉编程技巧，并将理论知识转化为实际编程技能。通过解答这些习题，学习者可以提高编程能力，为深入学习C++打下坚实基础。
扫一扫
1042
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
