C++程序设计基础与实践教程PDF电子书下载

第1章　概论 1

1.1　算法、程序和语言 1

1.1.1　算法和程序 1

1.1.2　低级语言和高级语言 1

1.2　面向过程和面向对象的程序设计 1

1.2.1　面向过程的程序设计 1

1.2.2　面向对象的程序设计 2

1.2.3 从C到C＋＋ 2

1.3 C＋＋程序的写出和运行 2

1.3.1 C＋＋程序简例 2

1.3.2 C＋＋程序从写出到运行的几个步骤 5

1.3.3　本书内容的安排 5

1.4　习题 5

第2章　基本数据、别名和指针 6

2.1　基本数据 6

2.1.1　基本数据类型 6

2.1.2　数据变量的存间、长度和取值范围 7

2.1.3　数据变量值的表示 9

2.1.4　字符串常量及其值 11

2.1.5　数据变量的声明和赋值 13

2.1.6 对数据变量的访问 13

2.2　别名 14

2.2.1　别名变量概念 14

2.2.2　别名变量的声明 15

2.2.3　用别名对变量进行访问例 15

2.3 指针 16

2.3.1　地址概念 16

2.3.2　指针变量概念 17

2.3.3　指针变量的声明和赋值 19

2.3.4　用指针对变量进行访问 20

2.3.5　二级指针变量概念 22

2.3.6　使用指针要特别注意指针的指向 25

2.4　对数据变量的保护 25

2.4.1　用const声明常值数据变量 25

2.4.2　在声明中用const对指针变量进行限定 26

2.4.3　在声明中用const对别名变量进行限定 27

2.5　习题 28

2.5.1　概念题 28

2.5.2　程序设计实践 31

第3章　数据的运算及简单输入／输出运算 32

3.1　运算符和表达式 32

3.1.1　运算符 32

3.1.2　表达式 33

3.2 sizeof（）运算符和sizeof（）表达式 33

3.2.1 sizeof（）运算符 33

3.2.2 sizeof（）表达式 33

3.3　算术运算符和算术表达式 34

3.3.1　基本算术运算符 34

3.3.2　基本算术表达式 34

3.3.3　自增自减运算符 35

3.4.4　自增自减表达式 35

3.4　关系运算符和关系表达式 36

3.4.1　关系运算符 36

3.4.2　关系表达式 37

3.5　逻辑运算符和逻辑表达式 37

3.5.1　逻辑运算符 37

3.5.2　逻辑表达式 38

3.5.3　某事件的逻辑判别式 40

3.6　位运算符和位运算表达式 41

3.6.1　位运算符 41

3.6.2　位运算表达式 41

3.7　条件运算符和条件表达式 44

3.7.1　条件运算符 44

3.7.2　条件表达式 44

3.8　赋值运算符和赋值表达式 45

3.8.1　赋值运算符 45

3.8.2　赋值表达式 46

3.9　逗号运算符和逗号表达式 47

3.9.1　逗号运算符 47

3.9.2　逗号表达式 47

3.10　基本数据混合运算时数据类型的转换 48

3.10.1　隐性类型转换 48

3.10.2　强迫类型转换 51

3.11　指针的增减运算 52

3.11.1　指针的整数增减和走步 53

3.11.2　指针类型的强迫转换 55

3.11.3　指针变量的自增自减和走步 57

3.11.4　指针两种走步的比较 59

3.12　简单的输入／输出运算 60

3.12.1　输入流和输出流 60

3.12.2　提取运算符“〉〉”和插入运算符“〈〈” 60

3.12.3　提取表达式和插入表达式 61

3.12.4　基本数据的输入／输出 62

3.13　简单输入／输出的格式控制 64

3.13.1　输入／输出的默认格式 64

3.13.2　用格式控制符对格式进行控制 64

3.14　习题 66

3.14.1　概念题 66

3.14.2　程序设计实践 70

第4章　程序的流程控制 71

4.1　程序流程的基本结构 71

4.1.1　三种基本结构 71

4.1.2　两种特殊语句 71

4.2　选择结构语句 71

4.2.1 条件语句 72

4.2.2 switch语句（又称开关语句） 76

4.3　循环结构语句 80

4.3.1　循环基本概念 80

4.3.2 while语句 81

4.3.3 do while语句 89

4.3.4 for语句 91

4.3.5　循环结构的嵌套 96

4.3.6 三种循环语句的比较 99

4.4　其他控制语句和函数 99

4.4.1 break语句 99

4.4.2 continue语句 100

4.4.3 goto语句 101

4.4.4 abort函数和exit函数 102

4.5　习题 102

4.5.1　概念题 102

4.5.2　程序设计实践 104

第5章　函数 107

5.1　函数的概念 107

5.1.1　函数概述 107

5.1.2　函数的定义 108

5.2　对函数的调用 110

5.2.1 被调函数的函数原型声明 110

5.2.2　函数的调用 110

5.2.3　函数调用流程 112

5.2.4　函数的递归调用 117

5.3 函数内外变量的作用域和生存期 124

5.3.1　作用域 124

5.3.2　生存期 128

5.4　函数内外的数据传递 131

5.4.1　函数通过参数进行数据传递 131

5.4.2　具有默认值的参数传递 138

5.4.3　函数通过返回值进行数据传递 141

5.4.4　函数通过全局变量传递数据 143

5.5 内联函数和函数的重载 144

5.5.1 内联函数 144

5.5.2　函数的重载 145

5.6　用指针对函数进行操作处理 147

5.6.1 函数指针 147

5.6.2　函数指针变量的声明和赋值 147

5.6.3　用函数指针调用函数 148

5.6.4　用通用函数处理函数 151

5.7　函数的多文件组织 154

5.7.1　模块化程序设计 154

5.7.2　源文件之间的访问 154

5.7.3　头文件 156

5.7.4　多文件组织的编译和链接 157

5.8　编译预处理 158

5.8.1　#include指令 158

5.8.2　#define和＃undef指令 159

5.9　条件编译 161

5.9.1 以宏名已被定义或未被定义作为条件 161

5.9.2 以表达式逻辑值为1或为0作为条件 163

5.9.3　关于条件编译的说明 163

5.10　习题 164

5.10.1 概念题 164

5.10.2　程序设计实践 168

第6章　数组 170

6.1　一维数组 170

6.1.1　一维数组的声明及初始化 170

6.1.2 对一维数组元素的直接访问 173

6.1.3　用一维数组名对元素进行访问 179

6.1.4　用指针变量对一维数组元素进行访问 181

6.1.5　用数组名作实参调用函数对一维数组进行处理 183

6.2　二维数组 186

6.2.1　二维数组的声明及初始化 186

6.2.2　对二维数组元素的直接访问 188

6.2.3　用二维数组名对元素进行访问 192

6.2.4　用指针变量对二维数组元素进行访问 195

6.2.5　用首元素地址或数组名作实参调用函数对二维数组进行处理 199

6.3 关于字符串的处理 207

6.3.1　字符串的输入和输出 207

6.3.2　用一维字符数组处理字符串 209

6.3.3　用库函数处理字符串 214

6.4　关于字符串组的处理 216

6.4.1　用二维字符数组处理字符串组 216

6.4.2　用一维字符指针数组处理字符串组 218

6.4.3　用一维字符指针数组名作实参调用函数处理字符串组 220

6.5　动态配给存间 222

6.5.1 new运算符的用法 222

6.5.2 delete运算符的用法 223

6.6　应用范例——姓名录的建立、排序和输出 225

6.6.1 问题的提出 225

6.6.2　分析 225

6.6.3　源程序及说明 225

6.7　习题 227

6.7.1　概念题 227

6.7.2　程序设计实践 230

第7章　枚举类型和结构类型 233

7.1　枚举类型 233

7.1.1　枚举类型概念 233

7.1.2　枚举变量的声明和赋值 234

7.1.3　调用函数对枚举变量输入和输出 235

7.1.4　枚举元素的组合状态 239

7.2　应用范例——C＋＋用格式状态字表示输入／输出格式的组合状态 241

7.2.1 将各种输入／输出格式定义为各个枚举元素 241

7.2.2　用格式状态字flag表示多项格式组合状态 242

7.2.3　用格式状态字通过格式控制符对多项格式的组合进行控制 242

7.3　结构类型 244

7.3.1　结构类型的定义 244

7.3.2　结构类型变量的声明、初始化和赋值 245

7.3.3 对结构类型变量的成员进行访问 247

7.3.4　结构类型数组 250

7.4　链表 255

7.4.1　链表的组成 255

7.4.2　如何表示结点成员变量 256

7.4.3　对链表结点的操作 258

7.4.4　调用函数把一个结点插入顺序链表 259

7.4.5　调用函数建立一条有序新链表 261

7.4.6　调用函数输出链表各结点数据 262

7.4.7　调用函数删除链表上具有指定值的一个结点 263

7.4.8　调用函数释放链表全部结点动配存间 265

7.5　应用范例——调用函数建立有序链表和删除指定结点 265

7.5.1 问题的提出 265

7.5.2　分析 266

7.5.3　源程序及说明 266

7.5.4　实例中的体会 270

7.6　用typedef来定义某类型的又一个标识符 270

7.6.1　用typedef定义某类型的又一个标识符的例子 270

7.6.2　用typedef定义某类型又一个标识符的方法步骤 271

7.7　习题 271

7.7.1　概念题 271

7.7.2　程序设计实践 273

第8章　类和对象 275

8.1　概述 275

8.2　类 276

8.2.1 类的定义 276

8.2.2 对类内各成员访问的控制规则 278

8.2.3　类的引用性声明 278

8.2.4　面向对象程序设计的多文件组织 279

8.3　对象 279

8.3.1 对象的声明 279

8.3.2 对对象的初始化 280

8.3.3 同类对象之间的整体赋值 281

8.3.4　访问对象的数据成员和成员函数 281

8.3.5　指向本对象的this指针 283

8.4　构造函数 287

8.4.1 构造函数的作用特点和定义形式 287

8.4.2 对构造函数的两点说明 289

8.4.3　拷贝构造函数的作用特点和定义形式 290

8.4.4　构造函数和new运算符 292

8.4.5　默认的构造函数和拷贝构造函数 293

8.5　析构函数 294

8.5.1 析构函数的作用特点和定义形式 294

8.5.2　默认的析构函数 296

8.6　类的静态成员 297

8.6.1　静态数据成员 297

8.6.2　静态成员函数 299

8.7　类的友元 301

8.7.1　友元的概念 301

8.7.2　运用友元的一个例题 302

8.7.3　友元声明的一般形式 304

8.7.4　关于友元的几点说明 305

8.8　类嵌套 305

8.8.1　类嵌套关系 305

8.8.2　嵌套类构造函数的定义和调用实例 305

8.8.3　嵌套类构造函数的定义形式 307

8.9　应用范例——构建学生成绩链表 307

8.9.1 问题的提出 307

8.9.2　类设计 308

8.9.3　创建链表的思路 308

8.9.4　源程序及说明 308

8.10　习题 311

8.10.1　概念题 311

8.10.2　程序设计实践 313

第9章　继承与派生 314

9.1　继承与派生的基本概念 314

9.1.1　继承、派生、基类、派生类的概念 314

9.1.2　基类和派生类的构成形式 314

9.1.3　派生类成员的组成和身份的确定 315

9.2　派生类 316

9.2.1　派生类的一个简例 316

9.2.2　派生类的定义形式 317

9.2.3　派生类成员、存间及身份具体确定 318

9.2.4　派生类的构造函数和析构函数 319

9.3　对派生类中同名成员的二义性的处理 321

9.3.1　类名加域运算符∷处理法 321

9.3.2　同名覆盖原理 324

9.3.3　对共同基类经多级多脉继承发生同名成员的处理 324

9.3.4　用虚基类避免一个数据多种版本问题 326

9.4　类的赋值兼容 329

9.4.1 公有派生类对象可以顶替基类对象 329

9.4.2　公有派生类对基类的赋值兼容 329

9.4.3　对一个程序实例运行结果的思考 330

9.4.4　类的赋值兼容规则的实质 332

9.5　应用范例——半工半读学生信息管理系统 334

9.5.1　问题的提出 334

9.5.2　类设计 335

9.5.3　源程序及说明 336

9.5.4　源程序呼喊改进 341

9.5.5 虚函数的提出 342

9.6　习题 342

9.6.1　概念题 342

9.6.2　程序设计实践 344

第10章　多态性 346

10.1　虚函数 346

10.1.1　虚函数的声明 346

10.1.2　虚函数在实施赋值兼容规则中所起的作用 347

10.1.3　虚析构函数 350

10.2　纯虚函数和抽象类 352

10.2.1　纯虚函数 352

10.2.2　抽象类 352

10.2.3　抽象类实例 352

10.3　运算符重载 357

10.3.1　运算符重载概念 357

10.3.2　运算符重载规则 357

10.3.3　运算符重载函数 357

10.4　用成员函数实现运算符重载 358

10.4.1 用成员函数实现双目运算符重载 358

10.4.2　用成员函数实现单目运算符重载 362

10.5　用友元函数实现运算符重载 365

10.5.1　用友元函数实现双目运算符重载 365

10.5.2　用友元函数实现单目运算符重载 368

10.6　提取运算符“〉〉”和插入运算符“〈〈”的重载 370

10.6.1　提取运算符和插入运算符对基本数据的重载 370

10.6.2　用友元函数实现提取运算符和插入运算符对自定义类型数据的重载 371

10.7　对象运算中的类型转换 372

10.7.1　转换构造函数 373

10.7.2　类型转换函数 373

10.7.3 对象运算中类型转换例 374

10.8　应用范例——虚函数多态性应用于定积分中 376

10.8.1 问题的提出 376

10.8.2　类设计 376

10.8.3　源程序及说明 377

10.9　习题 379

10.9.1 概念题 379

10.9.2　程序设计实践 380

第11章　输入／输出流类体系 382

11.1　基本概念 382

11.1.1　流类概念（端口、模式和成员函数） 382

11.1.2　缓冲流 383

11.1.3　流类体系 384

11.2　基本流类体系 384

11.2.1　基本流类体系组成 384

11.2.2　基本流类体系各组成部分简介 384

11.3 I/O标准流 385

11.3.1 I/O标准流概念 385

11.3.2 I/O标准流的端口和模式 385

11.3.3 常用于输入的成员函数 386

11.3.4　常用于输出的成员函数 388

11.3.5　用于格式控制的成员函数 389

11.3.6　用于检验出错的成员函数 391

11.4　文件流类体系 393

11.4.1　文件流类体系组成 393

11.4.2　文件流类体系各组成部分简介 393

11.5 I/O文件流 394

11.5.1 I/O文件流概念 394

11.5.2 I/O文件流的建立，端口和模式的确定 394

11.5.3　用于建立和关闭I/O文件流的成员函数 396

11.5.4 I/O文本文件流常用的成员函数 397

11.5.5 I/O二进制文件流常用的成员函数 402

11.6　应用范例——文件中建立正弦函数表 407

11.6.1 问题的提出 407

11.6.2　分析 408

11.6.3　源程序及说明 408

11.7　习题 409

11.7.1　概念题 409

11.7.2　程序设计实践 409

第12章　命名空间、模板和异常处理 411

12.1　命名空间 411

12.1.1 命名空间的定义与使用 411

12.1.2　标准命名空间std 415

12.1.3　用using引用命名空间 416

12.2　函数模板 419

12.2.1　函数模板的概念 419

12.2.2　函数模板的使用 420

12.2.3　函数模板的重载与特例 423

12.3　类模板 425

12.3.1　类模板的定义 425

12.3.2　类模板的使用 427

12.3.3　类模板的特例 428

12.4 STL简介 430

12.4.1　容器 431

12.4.2　算法 432

12.4.3　迭代器 433

12.4.4　函数对象 433

12.5　异常处理 435

12.5.1　异常处理的基本思想 435

12.5.2　异常的抛掷、检测与捕获处理 436

12.5.3　创建自己的异常类 439

12.5.4　指定函数抛掷的异常类型 441

12.5.5　异常处理的嵌套 442

12.5.6　抛掷异常时撤消对象 443

12.5.7　再次抛掷异常 445

12.5.8　构造函数中的异常处理 446

12.6　习题 447

12.6.1　概念题 447

12.6.2　程序设计实践 449