标准C++开发入门与编程实践PDF|Epub|txt|kindle电子书版本网盘下载

标准C++开发入门与编程实践PDF格式电子书版下载

注意：本站所有压缩包均有解压码： 点击下载压缩包解压工具

第1篇　C＋＋快速浏览第1章 了解C＋＋语言3

1.1 编程语言4

1.1.1　机器语言4

1.1.2　汇编语言4

1.1.3　高级语言5

1.2 C＋＋发展简史6

1.3 C＋＋开发环境7

1.3.1 C＋＋编译器7

1.3.2　C＋＋标准与编译器8

1.3.3 C＋＋开发环境9

1.3.4　开发环境的选择12

第2章　计算机的数值表示15

2.1　进制系统16

2.1.1 十进制16

2.1.2　二进制16

2.1.3　八进制和十六进制17

2.2　数值的表示19

2.2.1　整数的表示19

2.2.2 负数的表示19

2.2.3　整数的表示范围20

2.2.4　浮点数的表示20

2.2.5　观察数值的二进制表示22

2.3　字符的表示23

2.3.1 ASCII码23

2.3.2　汉字的编码25

2.3.3　UNICODE编码26

2.3.4　观察字符的二进制表示27

2.3.5 字符与字体29

2.3.6　键盘与输入法29

第3章　初识C＋＋程序33

3.1 开始C＋＋编程34

3.1.1　C＋＋程序的开发流程34

3.1.2　文件与工程（项目）35

3.2 在Dev-C＋＋中开发Hello World37

3.2.1 编辑Hello World38

3.2.2　编译连接Hello World38

3.2.3　运行Hello World39

3.3 在VC 2003中开发Hello World39

3.3.1 编辑Hello World40

3.3.2　编译连接Hello World42

3.3.3 运行Hello World43

3.4　可能遇到的问题43

3.5 理解Hello World45

3.5.1　main函数45

3.5.2 函数45

3.5.3　对象46

3.5.4　头文件46

3.5.5 名字空间46

3.5.6　标准输入输出47

3.5.7　编译器的行为48

第2篇　C＋＋数据表达第4章　C＋＋基础语法51

4.1 理解c=2πr52

4.2　注释53

4.3 标识符53

4.3.1　命名规则53

4.3.2　关键字54

4.4　数与类型55

4.5　基本类型55

4.5.1 整型56

4.5.2　浮点型56

4.5.3　布尔型57

4.5.4　字符型57

4.5.5　基本类型的字节长度57

4.6 字面常量58

4.6.1 整型常量59

4.6.2　浮点型常量59

4.6.3　布尔型常量59

4.6.4　字符型常量60

4.6.5 字符串常量60

4.6.6　字面常量的类型61

4.6.7 变量62

4.7　语句62

4.7.1　表达式62

4.7.2　语句62

4.7.3 声明语句62

4.7.4　赋值语句63

4.7.5　初始化语句63

4.7.6　使用调试器观察变量值64

4.8　操作符67

4.8.1　赋值操作符67

4.8.2　算术操作符68

4.8.3　关系操作符69

4.8.4　逻辑操作符69

4.8.5　条件操作符70

4.8.6　位操作符70

4.8.7　观察二进制位操作71

4.8.8　复合赋值操作符72

4.8.9　逗号操作符73

4.8.10　sizeof操作符74

4.8.11　typeid操作符74

4.8.12　操作符的优先级75

4.9　类型转换76

4.9.1 隐式转换76

4.9.2　显式转换76

4.9.3　算术转换77

第5章　数组与字符串79

5.1 数组80

5.1.1　数组的概念80

5.1.2　内存中的数组80

5.1.3　数组的初始化81

5.1.4　数组元素的访问82

5.1.5　安全使用数组下标82

5.1.6　多维数组83

5.2　字符串85

5.2.1　传统的字符串85

5.2.2　安全的使用字符串86

5.2.3　std∷string86

第6章　指针与引用89

6.1 指针90

6.1.1　指针的概念90

6.1.2　取址操作符91

6.1.3　取值操作符91

6.1.4　深入理解指针91

6.1.5　指针的比较92

6.1.6　指针的加减93

6.1.7　理解指针的运算93

6.1.8　数组与指针95

6.1.9　指针的指针96

6.1.10　指针数组96

6.2 引用96

6.2.1 引用的概念96

6.2.2　理解引用97

6.3　动态内存分配98

6.3.1 new98

6.3.2 delete98

6.3.3　数组的内存分配99

第7章　自定义数据类型101

7.1 结构102

7.1.1　结构的定义102

7.1.2　定义结构变量103

7.1.3　结构的数据成员103

7.1.4　结构成员的引用103

7.1.5　结构的初始化104

7.1.6　位域105

7.2　联合106

7.2.1　联合的定义106

7.2.2　使用联合107

7.3　枚举108

7.3.1　枚举定义108

7.3.2　枚举与int109

7.4　typedef109

7.5　数据类型修饰符110

7.5.1 const110

7.5.2　volatile112

第3篇　C＋＋过程设计第8章　C＋＋流程控制115

8.1 判断116

8.1.1 if116

8.1.2　语句块116

8.1.3 if...else116

8.1.4　if...else if...else117

8.1.5　流程图118

8.2　分支118

8.3 循环121

8.3.1　while121

8.3.2 do...while124

8.3.3　for125

8.4　跳转语句126

8.4.1 嵌套循环126

8.4.2　使用break中止循环127

8.4.3　使用break中止分支128

8.4.4 continue128

8.4.5 goto129

8.4.6　合理使用goto语句130

第9章　C＋＋函数133

9.1 函数134

9.1.1 函数134

9.1.2　函数调用134

9.1.3　使用调试器观察函数的调用135

9.1.4　函数参数137

9.1.5　返回值138

9.2　函数原型139

9.2.1 函数原型（function prototype）139

9.2.2　main（）函数141

9.2.3 定义带参数的main（）函数141

9.2.4　默认参数142

9.2.5　可变参数144

9.2.6　内联函数146

9.3 函数重载147

9.3.1 函数的重载147

9.3.2 重载函数的调用148

9.3.3　安全连接149

9.3.4　名字重组150

9.4　递归函数151

9.4.1　递归函数151

9.4.2　使用调试器观察函数的递归调用154

9.5　函数与指针155

9.5.1　指向函数的指针155

9.5.2　理解函数指针156

9.5.3 函数与值传递157

第10章　预处理159

10.1　预处理指令160

10.2　宏指令161

10.2.1 宏161

10.2.2　带参数的宏162

10.2.3　宏与常量、函数163

10.2.4　＃操作符164

10.2.5　＃＃操作符164

10.2.6　取消宏164

10.2.7　C＋＋预定义宏165

10.3　条件编译指令165

10.3.1 #if...#endif165

10.3.2　#else166

10.3.3　#elif166

10.3.4　#if defined和#if!defined167

10.3.5　#ifdef和#ifndef167

10.4　文件包含指令168

10.4.1 #include168

10.4.2　合理使用头文件169

10.5　其他标准指令170

10.5.1 #error170

10.5.2 #line171

10.5.3　#pragma171

第4篇　C＋＋面向对象编程第11章　C＋＋的类175

11.1　类与对象176

11.1.1　对象176

11.1.2　类176

11.2　类的设计177

11.2.1　类的定义177

11.2.2　对象的定义178

11.2.3　数据成员的访问178

11.2.4　成员访问控制178

11.2.5　成员函数179

11.2.6 内联成员函数181

11.2.7　成员函数的重载182

11.2.8　this指针182

11.2.9　内存中的类183

11.3　类的讨论187

11.3.1 类与结构187

11.3.2　抽象性187

11.3.3　封装性188

11.4　类的组合191

11.4.1　使用类的组合191

11.4.2　类的声明193

第12章　类的特殊函数195

12.1 构造函数196

12.1.1　构造函数（constructor）196

12.1.2　带参数的构造函数197

12.1.3　初始值列表198

12.2　成员初始值列表199

12.2.1　使用成员初始值列表199

12.2.2　对象成员初始化200

12.3　析构函数201

12.3.1　析构函数的定义201

12.3.2　对象成员的构造与析构202

12.4　特殊构造函数203

12.4.1　转换构造函数204

12.4.2　explicit205

12.4.3　拷贝构造函数206

12.5　操作符函数207

12.5.1　操作符重载208

12.5.2　一元操作符重载208

12.5.3　二元操作符重载209

12.5.4　全局操作符的重载210

12.5.5　可重载的操作符212

12.5.6　类型转换函数213

12.6　const与mutable214

12.6.1 const214

12.6.2 mutable216

12.7　友元217

12.7.1 声明某个函数为友元217

12.7.2　声明某个类的成员函数为友元218

12.7.3 声明某个类为友元219

第13章　继承221

13.1 类的继承222

13.1.1　继承的概念222

13.1.2　类的继承223

13.1.3 内存中的派生类224

13.1.4　protected226

13.1.5　基类访问控制227

13.2　构造与析构228

13.2.1　派生类的构造228

13.2.2　基类的初始化229

13.2.3　默认构造函数230

13.2.4　派生类的析构230

13.3　名字隐藏231

13.3.1　数据成员的隐藏231

13.3.2　成员函数的隐藏232

13.3.3　理解隐藏233

第14章　多态性235

14.1 类型转换236

14.1.1　向上转换236

14.1.2　向下转换236

14.2　虚函数与多态237

14.2.1 类型转换带来的问题237

14.2.2　虚函数238

14.2.3　虚函数的填充239

14.2.4　多态性239

14.2.5　虚析构函数240

14.2.6　纯虚函数241

14.2.7　抽象类241

14.3 多级继承242

14.3.1 多级继承的使用242

14.3.2　虚函数的多次填充244

14.4 多继承245

14.4.1 多继承的使用245

14.4.2　多继承带来的问题247

14.4.3　虚拟继承249

第5篇　C＋＋高级特性第15章　模板253

15.1 函数模板254

15.1.1 函数模板的概念254

15.1.2　模板参数与函数参数255

15.1.3 函数模板的实例化256

15.1.4　函数模板的重载256

15.1.5　函数模板的特化257

15.2　类模板258

15.2.1　类模板的概念258

15.2.2　类模板的成员函数258

15.2.3 包含多个参数的类模板259

15.2.4　类模板的默认参数260

第16章　C＋＋异常处理263

16.1　传统的错误处理264

16.2　抛出异常268

16.3　捕获异常268

16.3.1　使用catch捕获异常269

16.3.2　捕获不同类型的异常271

16.3.3　捕获所有的异常272

16.3.4　在catch块抛出异常273

16.3.5　未捕获的异常273

16.3.6　定制terminate（）的行为274

16.4　对抛出异常的声明275

第17章　名字空间与域277

17.1 名字空间278

17.1.1　名字空间定义278

17.1.2 using声明279

17.1.3 using指令279

17.1.4　名字空间的别名279

17.2　作用域279

17.3　局部作用域280

17.3.1　局部作用域的概念280

17.3.2　for语句的作用域280

17.3.3　case语句块的作用域280

17.3.4　函数的作用域281

17.4　局部变量的存储类型281

17.4.1 自动存储类型281

17.4.2　寄存器存储类型282

17.4.3　静态存储类型283

17.5　名字空间域284

17.5.1　全局域284

17.5.2　外部存储类型284

17.5.3　文件域286

17.5.4　名字空间域286

17.6　类域286

17.6.1　类域的概念286

17.6.2　static数据成员288

17.6.3　static成员函数290

17.7　作用域的嵌套291

17.7.1　语句块的嵌套291

17.7.2　名字空间的嵌套292

17.7.3　类的嵌套292

17.7.4　在语句块中定义类293

17.7.5　嵌套带来的隐藏293

17.8　对象的生命周期293

第18章　运行时类型信息297

18.1　动态类型的获取298

18.1.1　typeid关键字298

18.1.2　type_info298

18.1.3 打开RTTI开关299

18.1.4　获取对象的动态类型300

18.2　C＋＋风格的类型转换301

18.2.1　动态类型转换dynamic_cast301

18.2.2　静态类型转换static_cast303

18.2.3　再解释类型转换reinterpret_cast304

18.2.4 常类型转换const_cast304

第6篇　C＋＋编程实践第19章　C＋＋标准库307

19.1　C＋＋标准库的组成308

19.2 字符串库＜string＞309

19.2.1　字符串的构造与赋值309

19.2.2　字符串的连接309

19.2.3 字符串的比较309

19.2.4　字符串的下标310

19.2.5 子串310

19.2.6　字符串的查找311

19.2.7 string与C-style字符串311

19.2.8 空字符串312

19.3 复数类＜complex＞313

19.3.1　复数的构造313

19.3.2　复数的四则运算313

19.3.3　复数的操作函数313

19.4　异常类＜stdexcept＞314

19.5　C标准库316

19.5.1 assert宏317

19.5.2　类型函数318

19.5.3　数学函数318

19.5.4　类型转换函数319

19.5.5　随机数函数319

19.5.6　可变参数处理320

19.5.7　内存操作函数321

19.5.8 系统控制函数322

19.5.9　字符串处理函数323

19.5.10　时间处理函数324

第20章　C＋＋流327

20.1　输入输出流＜iostream＞328

20.1.1　输入输出流328

20.1.2　流操作符328

20.1.3　格式化输出函数329

20.1.4　格式操纵符330

20.1.5 流的输出332

20.1.6　缓冲输出332

20.1.7　流的输入333

20.1.8　状态标志335

20.2　标准输入输出流336

20.3 文件流＜fstream＞337

20.3.1 文件的打开和关闭338

20.3.2　二进制输入输出340

20.3.3 定位文件位置341

20.4　字符串流＜sstream＞342

20.4.1 ostringstream343

20.4.2　istringstream343

20.4.3 stringstream344

第21章 STL容器345

21.1　标准模板库346

21.1.1 STL的概念346

21.1.2 STL的组成348

21.1.3 STL的使用实例348

21.2　容器350

21.2.1　STL容器350

21.2.2　容器的模板参数351

21.2.3　容器的比较352

21.2.4　容器的赋值和交换352

21.2.5　operator[]352

21.2.6　指示器的获取352

21.2.7　元素的迭代访问353

21.2.8　容器的尺寸353

21.3 向量353

21.3.1 向量的构造354

21.3.2　向量元素的访问354

21.3.3 向量元素的添加355

21.3.4　向量元素的删除355

21.4　列表355

21.4.1　列表的构造356

21.4.2　列表元素的访问356

21.4.3　列表元素的添加356

21.4.4　列表元素的删除356

21.5　双端队列357

21.5.1　双端队列的构造357

21.5.2　双端队列元素的访问357

21.5.3　双端队列元素的添加357

21.5.4　双端队列元素的删除357

21.6　容器适配器358

21.6.1　栈358

21.6.2　队列358

21.6.3　优先级队列359

21.7 映射360

21.7.1　映射的构造360

21.7.2　映射元素的访问361

21.7.3　映射元素的添加362

21.7.4　映射元素的删除362

21.7.5　映射元素的查找362

21.7.6　多重映射362

21.8　集合363

21.8.1　集合的构造363

21.8.2　集合元素的访问364

21.8.3　集合元素的添加364

21.8.4　集合元素的删除364

21.8.5　集合元素的查找364

21.8.6　多重集合365

21.9　位集合365

21.9.1　位集合的概念366

21.9.2　位集合的构造366

21.9.3　位集合的输出366

21.9.4　位元素的操作366

21.9.5　位集合的赋值与转换367

21.9.6　位集合的尺寸367

21.9.7　位集合的比较367

21.9.8　位集合的位操作368

第22章　泛型算法369

22.1 指示器370

22.1.1　指示器的获取370

22.1.2　指示器的数据类型370

22.1.3　指示器的迭代370

22.1.4　迭代的方向372

22.1.5　指示器的迭代类型372

22.2　指示器适配器373

22.2.1　反向指示器373

22.2.2　插入型指示器374

22.3 函数对象374

22.4　算法376

22.4.1 查找算法377

22.4.2　排序与通用整序算法378

22.4.3　删除和替换算法379

22.4.4　排列组合算法380

22.4.5 算术算法380

22.4.6　生成和异变算法381

22.4.7 关系算法381

22.4.8　集合算法382

22.4.9　堆算法383

第23章　C＋＋实践指南385

23.1　提高代码的可读性386

23.1.1　不要吝啬注释386

23.1.2　不要吝啬空白388

23.1.3　爱惜标识符390

23.1.4　合理使用操作符函数391

23.1.5　合理使用别名391

23.1.6　合理使用跳转语句392

23.2　编写笨的程序394

23.2.1 书写正常的表达式394

23.2.2　使用bool类型进行判断395

23.2.3　保证对象的初始化396

23.2.4　尽量多写一些if397

23.2.5 不要再发明string类398

23.2.6　使用标准C＋＋399

23.3 合理使用内存399

23.3.1 C＋＋中的内存399

23.3.2 内存的非法访问400

23.3.3 内存泄漏402

23.3.4 内存泄漏的检测404

23.3.5　CMemory State405

23.3.6　智能指针（auto_ptr）406

23.4　合理使用OOP409

23.4.1　合理封装对象409

23.4.2　对象拷贝的产生409

23.4.3　对象的初始化412

23.4.4　对象的赋值与初始化413

23.4.5　合理使用继承与组合414

23.4.6　合理使用多继承416

23.4.7　合理使用虚函数和虚基类418

23.5　不要教条主义420

第24章　综合实践：《西游记》游戏模拟423

24.1 功能分析424

24.1.1　游戏运行界面424

24.1.2　游戏角色划分424

24.1.3　战斗的形成425

24.1.4　兵器的分配425

24.2　设计思路426

24.2.1　使用类和继承完成角色的设计426

24.2.2　使用文件流加载角色列表426

24.2.3　使用虚函数实现角色的多态427

24.2.4　使用操作符的重载429

24.2.5　使用异常处理提高程序的鲁棒性429

24.2.6　使用RTTI获取角色的类别430

24.2.7 使用STL容器管理角色431

24.2.8　使用STL容器管理兵器432

24.2.9　使用泛型算法完成查找与排序433

24.2.10　使用循环和判断完成主控逻辑435

24.3　实现详解435

24.3.1　Weapon436

24.3.2 Actor438

24.3.3　Monk443

24.3.4 ActorPowersAccumulater446

24.3.5 God446

24.3.6　Monster448

24.3.7　FollowerMonster449

24.3.8 GameException450

24.3.9 Game453

24.3.10　main（）函数468

24.4　运行并观察游戏469

24.4.1 actors.ini469

24.4.2　运行程序472