《C++自学通》求取 ⇩

译者序1

前言1

第一部分　介绍C++1

第1章　入门1

1.1　为什么C++是最佳选择1

目录1

1.1.1　过程化、结构化和面向对象的程序设计2

1.1.2 C++和面向对象的程序2

1.1.4 C++不仅仅是更好的C语言3

1.1.5　是否应当首先学习C语言3

1.1.3 C++是如何发展起来的3

1.2　为编程作准备4

1.3　区分C++、ANSI C++、Windows和其他领域的一些概念4

1.4　编译和链接源代码5

1.4.1　在集成开发环境中进行编译5

1.4.2　链接程序5

1.5　开发过程5

1.6 HELLO.CPP——第一个C++程序6

1.7　编译时出错8

1.8　小结8

1.9　问答8

2.1.1　逐个字符检查#Include语句10

2.1　一个简单程序的构成10

第2章　C++程序的构成10

2.1.2　逐行分析11

2.2　注释11

2.2.1　注释的类型11

2.2.2　使用注释12

2.3　功能12

2.4　小结15

2.5　问与答15

第3章 变量与常量16

3.1　什么是变量16

3.1.1　分配内存空间16

3.1.3 signed与unsigned17

3.1.2　整数的大小17

3.1.4　基本变量类型18

3.2　定义一个变量18

3.2.1　区分大小写19

3.2.2　关键字19

3.3　一次说明多个变量20

3.4　给变量赋值20

3.5　typedef语句21

3.6　何时使用short和long22

3.6.1　无符号整数的溢出22

3.7.1　数值常量23

3.7　常量23

3.6.2　有符号整数的溢出23

3.7.2　符号常量24

3.8　杖举常量24

3.9　小结25

3.10　问与答25

第4章　表达式与语句26

4.1　语句26

4.1.1　空白26

4.1.2　复合语句26

4.2　表达式27

4.3.2　数学运算符28

4.3　运算符28

4.3.1　赋值运算符28

4.4　组合使用赋值语句和数学运算符29

4.5　增量运算和减量运算29

4.6　优先级31

4.7　括号嵌套31

4.8　“真”与“假”的实质32

4.9　关系运算符32

4.10　if语句33

4.10.1 else子句33

4.10.2　高级if语句34

4.11　在嵌套if语句中使用花括号36

4.12　逻辑运算符38

4.12.1　逻辑与38

4.12.2　逻辑或38

4.12.3　逻辑非38

4.13　关系优先级39

4.14　深入讨论逻辑值“真”与“假”39

4.15　小结39

4.16　问与答40

第5章 功能41

5.1　什么是功能41

5.2.1　功能的说明42

5.2　说明并定义功能42

5.2.2　功能的定义43

5.3　局部变量45

5.4　全局变量47

5.5　功能的语句47

5.6　功能的实参47

5.7　形参是局部变量47

5.8　返回值49

5.9　缺省形参50

5.10　功能的重载52

5.10.1　深入研究功能的机理53

5.12　问与答55

5.10.2　栈与功能55

5.11　小结55

第二部分　类57

第6章　基本类57

6.1　创建新类型57

6.1.1　什么是类型57

6.1.2　为什么要创建一个新类型57

6.2　类与成员58

6.2.1　类的说明58

6.2.4　类与对象59

6.3　访问类的成员59

6.2.3　定义一个对象59

6.2.2　有关命名的约定59

6.4　私有成员和公有成员60

6.5　类方法的实现61

6.6　构造函数和析构函数63

6.6.1　缺省构造函数64

6.6.2　编译程序提供的构造函数64

6.7　小结66

6.8　问与答67

7.1 const型成员函数68

7.2　接口与方法68

第7章 深入了解类68

7.3　在何处放置类的说明以及方法的定义69

7.4　内联实现70

7.5　以其他的类作为数据成员的类72

7.6　小结75

7.7　问与答75

第8章 高级程序流程控制77

8.1　循环77

8.1.1 goto语句——循环语句的起源77

8.1.2　为什么现在不使用goto语句78

8.2 while循环78

8.2.1　更加复杂的while语句79

8.2.2 continue和break80

8.2.3 while（1）循环82

8.3 do...while循环83

8.4 for循环84

8.4.1　高级for循环86

8.4.2　空的for循环88

8.4.3　循环嵌套89

8.5 switch语句90

8.6　小结91

8.7　问与答91

第9章　指针93

9.1　什么是指针93

第三部分 内存管理93

9.1.1　在一个指针中存储地址值95

9.1.2　指针名96

9.1.3　目标访问运算符96

9.1.4　指针、地址和变量96

9.1.5　使用指针处理数据97

9.1.6　检查地址值98

9.2　为什么使用指针99

9.3　栈和自由存储区100

9.3.1 new101

9.3.2 delete101

9.4　小结103

9.3.3　内存丢失103

9.5 问与答104

第10章 高级指针105

10.1　在自由存储区内创建对象105

10.2　删除对象105

10.3　访问数据成员106

10.4　自由存储区中的成员数据107

10.5 this指针109

10.6 this指针的用途110

10.7　迷途指针或悬浮指针110

10.8.1 const型指针和const型成员函数111

10.8 const型指针111

10.8.2 const型this指针113

10.9　小结113

10.10　问与答113

第11章 引用114

11.1　什么是引用114

11.2　说明一个引用114

11.3　对引用使用取址运算符115

11.4　什么可以被引用117

11.5　空指针和空引用118

11.6　通过引用传递的方式给函数传递实参118

11.6.1　使用指针使swap（）函数正常工作119

11.6.2　使用引用实现swap（）120

11.7　理解函数的域名和原型122

11.8　返回多个值122

11.9　小结125

11.10　问与答125

第12章 高级引用和指针126

12.1　使用引用传递的方式以提高效率126

12.2　使用引用代替指针131

12.3　如何确定使用引用还是指针133

12.4　不要返回一个非作用域中的目标对象的引用133

12.5　返回一个在堆中的对象的引用134

12.7　小结136

12.6　指针的传递136

12.8　问与答137

第四部分　功能强大的工具139

第13章 高级函数139

13.1　重载成员函数139

13.2　使用缺省值141

13.4　缺省构造函数143

13.7　复制构造函数143

13.3　在使用缺省值或重载函数之间选择143

13.5　重载函数144

13.6　初始化对象144

13.8　小结148

13.9　问与答149

第14章 运算符重载150

14.1　运算符重载150

14.1.1　定义一个增量函数151

14.1.2　重载后置运算符152

14.1.3　前置与后置的区别152

14.1.4　operator+154

14.1.5　重载operator+156

14.1.7　何时需要重载157

14.1.8　operator＝157

14.1.6　运算符重载的限制157

14.2　转换运算符159

14.3　小结163

14.4　问与答163

第15章　数组164

15.1　什么是数组164

15.2　数组元素164

15.3　数组越界166

15.4　界桩错误166

15.5　初始化数组166

15.6 对象数组167

15.7　多维数组168

15.8　关于内存170

15.9　指针数组170

15.10　说明自由存储区中的数组172

15.11　指向数组的指针和指针数组172

15.12　指针与数组名173

15.13　删除自由存储区中的数组174

15.14　char型数组175

15.15　strcpy（）和strnepy（）176

15.16　串类178

15.17　小结178

15.18　问与答178

16.1.1　继承与派生179

16.1　什么是继承179

第五部分　继承和多态179

第16章 继承179

16.1.2　动物王国180

16.1.3　派生的语法180

16.2　私有访问权限和保护型访问权限182

16.3　构造函数和析构函数184

16.4　重置函数190

16.4.1　重载与重置192

16.4.2　隐藏基类方法192

16.4.3　调用基类方法193

16.6　问与答195

16.5　小结195

第17章 多态与派生类196

17.1　虚方法196

17.1.1　虚成员函数的工作机理199

17.1.2　不能用基类指针调用基类中不存在的方法200

17.1.3　对象分离201

17.1.4　虚析构函数203

17.1.5　虚复制构造函数203

17.1.6　虚方法的开销206

17.2　小结206

17.3　问与答206

18.1　单重继承的问题208

第18章 高级多态208

18.2　抽象数据类型212

18.2.1　纯虚函数215

18.2.2　抽象的复杂层次结构219

18.2.3　如何决定是否使用抽象类型223

18.3　小结223

18.4　问与答224

第19章　链表225

19.1　链表和其他结构225

19.2　实例研究225

19.3　组成部件226

19.4　学会使用面向对象的方式进行程序设计234

19.5　小结234

19.6　问与答235

第六部分　特别主题237

第20章 特殊的类与函数237

20.1　静态成员数据237

20.2　静态成员函数239

20.3　包容241

20.3.1　访问被包容类的成员246

20.3.4　值复制与引用复制247

20.4　友元类247

20.3.3　包容的开销247

20.3.2　对被包容成员的选择性访问247

20.5　友元函数248

20.6　函数指针248

20.6.1　速记调用法251

20.6.2　函数指针数组251

20.6.3　把函数指针传递给另一个函数253

20.6.4　对函数指针使用typedef255

20.7　成员函数指针257

20.8　小结261

20.9　问与答262

第21章　预处理程序263

21.1　预处理程序和编译程序263

21.2　查看中间格式263

21.3　使用#define263

21.3.1　将#define用于常量264

21.3.2　将#define用于测试264

21.3.3　#velse预编译命令264

21.4 包含与包含警戒265

21.4.3　条件编译266

21.5　函数宏266

21.4.2　取消定义266

21.4.1　在命令行进行定义266

21.5.1　为什么要使用括号267

21.5.2　宏、函数和模板268

21.6　串的处理269

21.6.1　串转换269

21.6.2　连接269

21.7　预定义宏270

21.8　小结281

21.9　问与答282

22.2　模拟一个报警系统283

22.1　开发过程283

第22章 面向对象的分析和设计283

第七部分　高级主题283

22.2.1　概念表达284

22.2.2　分析需求284

22.2.3　高层设计和低层设计284

22.2.4　其他对象285

22.2.5　类的设计285

22.2.6　如何报警286

22.2.7　事件循环286

22.3　实例研究：PostMaster288

22.3.1　权衡并取舍289

22.3.2　功能分解并逐步求精289

22.3.3　信息格式289

22.3.5　有根与无根的层次结构290

22.3.4　最初的类的设计290

22.3.6　设计接口292

22.3.7　创建一个原型293

22.3.8　80/80法则293

22.3.9　设计PostMasterMessage类293

22.3.10　应用程序接口294

22.3.11　分组进行295

22.3.12　继续进行设计295

22.3.13　使用驱动程序296

22.4　小结303

22.5　问与答303

23.2　参数化类型304

23.3　模板的定义304

第23章　模板304

23.1　什么是模板304

23.4　使用模板项312

23.5　标准模板库319

23.6　小结320

23.7　问与答320

第24章 异常和出错处理321

24.1　程序死区、错误和损坏的代码321

24.2　异常322

24.3.3　通过引用传递和多态的方式处理异常327

24.3.2　多于一个的catch语句327

24.3.1　处理异常327

24.3　使用try语句块和catch语句块327

24.4　以下的步骤332

24.5　风格332

24.5.1　花括号332

24.5.2　过长的行332

24.5.3 switch语句332

24.5.4　程序文本333

24.5.5　标识符333

24.5.6　标识符的拼写和大写334

24.5.7　注释334

24.5.8　访问权限334

24.6　后记335

24.6.2　所需的读物335

24.6.1　到哪里获得帮助和建议335

24.5.9　类的定义335

24.5.12 const335

24.5.11 asset（）335

24.5.10 include文件335

24.6.3　杂志336

24.6.4　保持联系336

第八部分　附录337

附录A 运算符优先级337

附录B C＋+关键字338