C++程序设计PDF电子书下载

第1章 程序设计概述 1

1.1 程序设计的基本知识 1

1.1.1 程序设计概念 1

1.1.2 程序设计步骤 3

1.1.3 程序设计语言 4

1.1.4 程序设计方法 5

1.1.5 面向对象程序设计中的基本概念 6

1.1.6 程序设计的评判标准 8

1.2 C＋＋语言简介 8

1.2.1 C＋＋语言的产生和发展 8

1.2.2 C＋＋语言的语法规则 9

1.2.3 C＋＋程序 10

1.3 C＋＋程序的实现 12

1.3.1 C＋＋程序的调试步骤 12

1.3.2 Visual C++ 6.0编译系统简介 12

1.4 上机实训 17

1.4.1 实训一：简单的C＋＋程序 17

1.4.2 实训二：带子函数的C＋＋程序 18

1.4.3 实训三：带类的C＋＋程序 19

本章小结 19

习题 20

第2章 C＋＋基础知识 22

2.1 C＋＋的数据 22

2.1.1 数据类型 22

2.1.2 常量 23

2.1.3 变量 26

2.2 C＋＋的运算符 28

2.2.1 运算符的分类 28

2.2.2 算术运算符 29

2.2.3 关系运算符 30

2.2.4 逻辑运算符 30

2.2.5 位运算符 31

2.2.6 赋值运算符 33

2.2.7 其他运算符 34

2.3 C＋＋的表达式 36

2.3.1 表达式的种类 36

2.3.2 表达式的运算 38

2.3.3 类型转换 38

2.4 顺序结构程序设计 40

2.4.1 顺序结构概述 40

2.4.2 键盘输入 41

2.4.3 屏幕输出 41

2.5 上机实训 43

2.5.1 实训一：数据类型实例 43

2.5.2 实训二：数据运算实例 44

本章小结 45

习题 46

第3章 选择结构的程序设计 49

3.1 选择结构概述 49

3.1.1 选择结构的概念 49

3.1.2 选择结构程序的设计步骤 50

3.2 条件语句 50

3.2.1 条件语句的格式 50

3.2.2 条件语句的应用 53

3.3 开关语句 54

3.3.1 开关语句的格式 54

3.3.2 开关语句的执行过程 55

3.3.3 开关语句的应用 55

3.4 上机实训 57

3.4.1 实训一：用if语句实现选择结构程序设计 57

3.4.2 实训二：用switch语句实现选择结构程序设计 58

本章小结 59

习题 60

第4章 循环结构的程序设计 64

4.1 循环结构概述 64

4.1.1 循环结构的概念 64

4.1.2 循环结构的设计步骤 65

4.2 for语句 65

4.2.1 for语句的格式 65

4.2.2 for语句的执行过程 65

4.2.3 for语句的应用 66

4.3 while语句 67

4.3.1 while语句的格式 67

4.3.2 while语句的执行过程 67

4.3.3 while语句的应用 68

4.4 do-while语句 68

4.4.1 do-while语句的格式 68

4.4.2 do-while语句的执行过程 69

4.4.3 do-while语句的应用 69

4.5 多重循环结构 69

4.5.1 多重循环的格式 70

4.5.2 多重循环的执行过程 70

4.5.3 多重循环的应用 70

4.6 break语句和continue语句 71

4.6.1 break语句 71

4.6.2 continue语句 72

4.7 综合应用实例 72

4.7.1 递推算法应用实例 73

4.7.2 穷举算法应用实例 74

4.7.3 打印字符图形应用实例 74

4.8 上机实训 75

4.8.1 实训一：循环控制语句 75

4.8.2 实训二：多重循环程序设计 76

4.8.3 实训三：循环综合应用程序设计 77

本章小结 77

习题 78

第5章 复杂数据的程序设计 83

5.1 复杂数据概述 83

5.1.1 引入复杂数据的目的 83

5.1.2 构造数据类型的分类 84

5.2 数组 84

5.2.1 数组概述 84

5.2.2 一维数组的定义与使用 85

5.2.3 二维数组的定义与使用 87

5.2.4 字符数组的定义与使用 90

5.2.5 数组应用实例 93

5.3 结构体 96

5.3.1 结构体的概述 96

5.3.2 结构体变量的定义与使用 97

5.3.3 结构体数组 99

5.3.4 结构体应用实例 100

5.4 联合体 100

5.4.1 联合体的定义 100

5.4.2 联合体变量的定义与使用 101

5.4.3 联合体应用实例 102

5.5 枚举 103

5.5.1 枚举类型的定义 103

5.5.2 枚举变量的定义与使用 103

5.6 综合应用实例 105

5.7 上机实训 106

5.7.1 实训一：一维数组的应用 106

5.7.2 实训二：二维数组的应用 107

5.7.3 实训三：字符数组的应用 108

5.7.4 实训四：结构体类型的应用 108

5.7.5 实训五：联合体类型的应用 108

5.7.6 实训六：枚举类型的应用 109

本章小结 110

习题 110

第6章 模块化的程序设计 115

6.1 模块化程序设计概述 115

6.1.1 模块化程序设计的概念 115

6.1.2 函数的基本概念 116

6.2 函数的定义与声明 117

6.2.1 函数的定义 117

6.2.2 函数的声明 118

6.3 函数的参数、返回值和调用方式 119

6.3.1 函数的参数和返回值 119

6.3.2 函数的调用方式 120

6.4 函数的嵌套调用与递归调用 124

6.4.1 函数的嵌套调用 124

6.4.2 函数的递归调用 125

6.5 内联函数与重载函数 127

6.5.1 内联函数 127

6.5.2 重载函数 129

6.6 变量的作用域和生存期 130

6.6.1 变量的作用域 130

6.6.2 变量的生存期 132

6.7 变量的存储类型 132

6.7.1 自动类型 132

6.7.2 寄存器类型 133

6.7.3 静态类型 134

6.7.4 外部类型 135

6.8 函数的存储类型 137

6.8.1 内部函数 137

6.8.2 外部函数 138

6.9 上机实训 139

6.9.1 实训一：函数调用方式 139

6.9.2 实训二：函数的嵌套调用和递归调用 140

6.9.3 实训三：重载函数 140

6.9.4 实训四：变量的作用域、生存期和存储类型 141

本章小结 141

习题 142

第7章 指针与引用的程序设计 146

7.1 指针的基本概念 146

7.1.1 引入指针的目的 146

7.1.2 指针的定义 147

7.1.3 指针的运算 148

7.2 数组和指针 150

7.2.1 数组指针 150

7.2.2 指针数组 154

7.3 函数和指针 157

7.3.1 指针作为函数参数 157

7.3.2 返回指针的函数 160

7.3.3 指向函数的指针 163

7.4 引用 164

7.4.1 引用的定义 164

7.4.2 引用的使用 165

7.5 动态存储管理 168

7.5.1 简单变量的动态存储 169

7.5.2 数组的动态存储 170

7.6 上机实训 173

7.6.1 实训一：指针与数组的应用 173

7.6.2 实训二：指针与函数的应用 173

7.6.3 实训三：引用与动态存储的应用 175

本章小结 175

习题 176

第8章 类与对象的程序设计 180

8.1 类 180

8.1.1 引入类的目的 180

8.1.2 类的定义 181

8.2 对象 183

8.2.1 对象的定义 183

8.2.2 对象的使用 184

8.3 类中的成员 185

8.3.1 构造函数 185

8.3.2 析构函数 187

8.3.3 复制构造函数 189

8.3.4 成员函数的重载 190

8.3.5 成员函数参数的默认值 192

8.3.6 内联函数与外联函数 194

8.3.7 静态成员 195

8.3.8 常成员 196

8.4 友元函数和友元类 198

8.4.1 友元函数 198

8.4.2 友元类 199

8.5 指向对象的指针 200

8.5.1 指向对象的指针类型 200

8.5.2 指向对象指针的应用 201

8.6 上机实训 202

8.6.1 实训一：类和对象的定义与使用 202

8.6.2 实训二：类中特别成员的使用 203

本章小结 204

习题 204

第9章 复杂对象的程序设计 207

9.1 常对象、子对象与堆对象 207

9.1.1 常对象 207

9.1.2 子对象 208

9.1.3 堆对象 210

9.2 对象数组 212

9.2.1 对象数组的定义 212

9.2.2 对象数组的应用 212

9.2.3 对象指针数组 214

9.3 类型转换与转换函数 215

9.3.1 类型隐含转换 216

9.3.2 转换函数 217

9.4 类作用域与对象的生存期 218

9.4.1 类作用域 218

9.4.2 对象的生存期 221

9.5 综合应用实例 225

9.5.1 综合应用实例一 225

9.5.2 综合应用实例二 226

9.6 上机实训 227

9.6.1 实训一：复杂对象的编程 227

9.6.2 实训二：类型转换、类的作用域与对象的生存期 228

本章小结 229

习题 230

第10章 类继承的程序设计 232

10.1 类继承概述 232

10.1.1 基类与派生类的概念 232

10.1.2 派生类的定义格式 233

10.1.3 继承的3种方式 234

10.1.4 派生类的使用 235

10.2 单继承 235

10.2.1 单继承的定义 235

10.2.2 单继承的使用 237

10.3 多继承 239

10.3.1 多继承的定义 239

10.3.2 多继承的使用 241

10.3.3 多继承中的问题 242

10.4 虚基类 243

10.4.1 虚基类的概念 243

10.4.2 虚基类的声明 243

10.5 综合应用实例 246

10.5.1 综合应用实例一 246

10.5.1 综合应用实例二 249

10.6 上机实训 251

10.6.1 实训一：不同继承方式下成员的访问权限 251

10.6.2 实训二：类的继承和虚基类的使用 253

本章小结 253

习题 254

第11章 类多态的程序设计 257

11.1 类多态概述 257

11.1.1 类多态的概念 257

11.1.2 类多态的分类 257

11.2 函数重载 258

11.2.1 函数参数类型重载 258

11.2.2 函数参数个数重载 258

11.3 运算符重载 259

11.3.1 引入目的 259

11.3.2 运算符重载的使用 260

11.3.3 应用实例 262

11.4 静态联编和动态联编 265

11.4.1 静态联编 265

11.4.2 动态联编 266

11.5 虚函数 267

11.5.1 虚函数的基本概念 267

11.5.2 虚函数的使用 269

11.6 纯虚函数与抽象类 272

11.6.1 纯虚函数 272

11.6.2 抽象类 273

11.7 上机实训 275

11.7.1 实训一：静态多态的程序设计 276

11.7.2 实训二：动态多态的程序设计 276

本章小结 277

习题 278

第12章 模板的程序设计 281

12.1 模板的基本概念 281

12.1.1 模板的概念 281

12.1.2 模板的分类 282

12.2 函数模板 282

12.2.1 函数模板的定义 283

12.2.2 函数模板的使用 283

12.3 类模板 288

12.3.1 类模板的定义 289

12.3.2 类模板的使用 291

12.4 上机实训 294

12.4.1 实训一：函数模板 294

12.4.2 实训二：类模板 295

本章小结 297

习题 297

第13章 I/O流的程序设计 299

13.1 I/O流概述 299

13.1.1 流的概念 299

13.1.2 流类库的结构 300

13.2 屏幕输出流 301

13.2.1 cout的使用 301

13.2.2 输出流函数 308

13.3 键盘输入流 309

13.3.1 cin的使用 309

13.3.2 输入流函数 310

13.3.3 重载输入／输出运算符 311

13.4 文件流 313

13.4.1 文件的基本概念 313

13.4.2 文件的操作函数 314

13.4.3 文件应用实例 318

13.5 上机实训 321

13.5.1 实训一：控制输出宽度函数width（）和setw（）的使用 321

13.5.2 实训二：重载“＜＜”和“＞＞”方法 322

13.5.3 实训三：文件的使用 324

本章小结 326

习题 326

第14章 C＋＋课程设计 328

附录A 字符的ASCII码表 330

附录B 格式控制符及附加格式控制符 331

附录C C＋＋的库函数 332

附录D 参考答案 336

参考文献 340