BORLAND C++ 3.0DOS和WINDOWS编程技巧与实例 下PDF电子书下载

第零章 前言 1

0.1 本书适合的读者对象 1

0.2 本书的内容 1

目录 1

0.3　本书的结构安排 2

0.4　本书的使用方法 2

0.5 C和C++编程练习注意事项 2

0.6　选择Borland编译器 3

第一部分　使用Borland C++的基本特征 5

第一章 启动Borland C++ 5

1.1　运行安装程序 5

1.1.1 安装Borland C++ 5

1.2 集成开发环境（IDE）的使用 7

1.2.1 启动IDE 7

1.2.2.1 菜单系统 9

1.2.2 使用IDE的菜单和窗口 9

1.2.2.2　窗口系统 10

1.3 配置Borland C++ 13

1.3.1 设置IDE选择项 13

1.3.2　使用BCINST 15

1.4　编写第一个C语言程序 18

1.4.1 理解C程序的结构 18

1.4.1.1　预处理器指令 20

1.4.1.2　全局说明 21

1.4.1.2 main（）函数 22

1.4.1.3　用户定义的函数 22

1.4.2　使用编辑器编写程序 23

1.5　介绍库函数 26

1.5.1 使用一些基本的输入函数 26

1.5.1.1　get（）函数 27

1.5.1.2　scanf（）函数 28

1.5.2　使用一些基本的输出函数 30

1.5.2.1　？put（）函数 30

1.5.2.2　printf（）函数 31

1.5.3　使用一些格式转换函数 31

1.5.3.1　atoi（）函数 31

1.5.3.2　toupper（）函数 32

1.6　练习 33

1.7　总结 34

第二章　理解C语言的基础 36

2.1 预备知识 36

2.1.1 理解源文件、目标文件和装载模块 36

2.1.2　理解程序的逻辑和执行流程 37

2.1.2.1　使用条件指令 37

2.1.2.2　使用循环指令 41

2.2　使用基本数据类型 43

2.2.1 理解C语言的基本数据类型 43

2.2.1.1 整数 43

2.2.1.2　浮点数 44

2.2.1.3　字符型数据 45

2.2.2　在何处定义数据对象 46

2.3　编写C语言表达式和语句 48

2.3.1　理解表达式和语句 49

2.3.1.1 C语言的操作符集 50

2.4　控制类型转换 53

2.4.1　理解隐式类型转换 53

2.5　显式类型转换的使用 55

2.6　使用C的宏 56

2.6.1 定义类似对象的宏 56

2.6.2　定义类似函数的宏 59

2.8　总结 62

2.7　练习 62

第三章　使用C语言函数 64

3.1 理解main（）函数和库函数 64

3.1.1 编写main（）函数 64

3.1.2　使用库函数 66

3.1.2.1 哪些库函数可以利用 66

3.1.2.2　在程序中加入库函数 67

3.2 编写用户自己的函数 69

3.2.1 编写函数原型 69

3.2.2　把参数传送给函数 71

3.3　函数返回值 74

3.3.1 定义和使用函数类型 74

3.3.2 象数据项一样使用函数 76

3.4　理解存储类别 76

3.4.1 确定变量的作用域 77

3.4.2　确定变量的生存期 78

3.4.3　确定变量的连接 79

3.5　使用高级的程序控制逻辑 80

3.5.1 编写循环控制语句 80

3.5 1.1 使用goto语句 80

3.5.1.2　使用break语句 81

3.5.1.3　使用continue语句 81

3.5.2 改变程序的执行流程 82

3.5.2.1 使用exit（）和abort（）函数 82

3.5.2.2　使用system（），exec...（），和spawn（）函数 83

3.6　使用可变参数表 84

3.6.1 设计可变参数表 84

3.6.2　使用va...（）函数 85

3.7　练习 89

3.8　总结 89

4.1.1 理解C的类型划分方案 91

4.1 理解标准C语言的派生类型 91

第四章　使用指针和派生类型 91

4.1.2　从旧类型中创建新类型 92

4.1.3　什么是不完全类型 92

4.2　理解C语言的指针 94

4.2.1 理解间接寻址 95

4.2.2　RAM地址和系统装入程序 95

4.2.2.1 使用C语言的间接操作符和取址操作符 100

4.2.3　使用数组和串 102

4.2.3.1 声明和使用对象数组。 102

4.2.3.2　理解C语言的串 105

4.2.4　使用结构和联合类型 108

4.2.4.1 从不同类型中建立结构类型 108

4.2.4.2　联合是结构对象的变化形式 111

4.3　使用指向函数的指针 113

4.3.1 指向函数的指针声明和初始化 113

4.3.2 利用指针引用某函数 114

4.4　在动态内存中使用指针 117

4.4.1 C语言程序和动态内存 117

4.4.2　使用动态存储 119

4.5 练习 125

4.6 总结 125

第五章　建立、编译和测试Borland C++程序 127

5.1 在一个程序中使用几个源文件 127

5.1.1　确定把哪些函数放在源文件中 127

5.1.2　设置Borland C++工程文件 143

5.2　理解外部引用 145

5.2.1　使用关键字extern 145

5.2.2　使用外部函数 146

5.3　为外部模块编写头文件 147

5.3.1 确定头文件中的内容 147

5.3.2 包含用户提供的头文件 148

5.4　在头文件中使用带条件的编译程序说明 149

5.5　用IDE（集成开发环境）编译和运行程序 151

5.5.1 编译和运行简单的程序 151

5.5.2　编译和运行复杂的程序 152

5.6　介绍集成Debugger 154

5.6.1 使用step over命令缩小搜索范围 154

5.6.2　使用Trace into命令来对问题进行准确定位 155

5.6.3　设置和删除断点 156

5.7 练习 157

5.8　总结 158

第六章 使用Borland C++输入／输出函数库 159

6.1 理解I/O概念 159

6.1.1　理解文件与设备 159

6.1.2　理解文件与流 160

6.2　利用标准流进行I/O 162

6.1.3　文本流和二进制流 162

6. 2.1 使用格式化I/O函数 163

6.2.2　理解scanf（）函数 167

6.2.3　理解printf（）函数 170

6.2.4　使用字符I/O函数 173

6.3　使用文件控制函数 177

6.3.1 打开文件、关闭文件和控制文件 177

6.3.2　控制文件缓冲区 180

6.4 使用直接文件I/O函数 182

6.4.1 理解直接I/O的概念 182

6.4.2　读写直接文件 183

6.5　使用文件定位函数 189

6.5.1 得到当前文件位置 189

6.5.2　设定一个新文件位置 190

6.6.1 检测文件I/O错误 192

6.6.2　显示和清除文件I/O错误 192

6.6　处理文件I/O错误 192

6.7　练习 193

6.8 小结 193

第七章　存储模式与VROOMM技术 195

7.1 80×86的体系结构 195

7.1.1 段（Segment）、节（Paragraph）以及偏移地址（Offset） 195

7.1.2　CPU的地址寄存器 197

7.2　near指针、far指针和huge指针 199

7.2.1　选择想要的指针大小 199

7.2.2　near、far和huge说明符 200

7.3　六个Borland C++存储模式 203

7.3.1 决定使用哪种存储模式 203

7.3.2　以混合模式编程 204

7.4　创建COM型的可执行程序文件 206

7.4.1 使用COM文件 206

7.5　覆盖管理程序 208

7.5.1　覆盖管理程序会做什么 209

7.5.2　Borland的VROOMM 209

7.6　设计和创建覆盖程序 211

7.6.1 决定哪些模块要覆盖 211

7.6.2　覆盖程序的编译和链接 212

7.7　练习 214

7.8 小结 215

第八章　使用Borland C++的视频函数 217

8.1 IBM/PC的文本方式 217

8.1.1 PC显示器适配器和屏幕的概述 217

8.1.2　掌握存储变换屏幕I/O 218

8.2　控制文本屏幕 219

8.2.1　使用文本方式控制函数 219

8.2.2　使用直接控制台I/O以获得高性能 223

8.3　使用窗口函数 223

8.4.1 象素点与调色板 227

8.4 了解IBM-PC的图形方式 227

8.4.2　控制图形屏幕 231

8.5　介绍BGI图形库 233

8.5.1　使用画图和填充函数 233

8.5.2　控制屏幕和视口 238

8.6　在图形方式下显示文本 238

8.6.1　BGI字体 239

8.6.2　使用图形方式下的文本函数 239

8.7　练习 242

8.8 小结 242

第九章　使用Turbo Debugger和Turbo Profiler 244

9.1 启动Turbo Debugger 244

9.1.1 理解错误和调试程序的概念 244

9.2　使用Turbo Debugger 246

9.2.1 用Turbo Debugger运行程序 246

9.1.2　准备在IDE里运行Turbo Debugger 246

9.2.2　观察数据 250

9.3　使用高级调试功能 252

9.3.1 改变程序中变量或表达式的值 252

9.3.2　设置断点 253

9.4　使用Turbo Profiler 254

9.4.1 什么是“剖析”（profiling） 254

9.4.2 启动Turbo Profiler 255

9.4.3 了解基本的剖析信息 257

9.5 使用高级剖析功能 260

9.5.1　选择剖析区域 261

9.5.2　显示剖析统计数据 263

9.5.3　积极剖析与消极剖析 265

9.6　练习 266

9.7 小结 266

10.1 使用直接插入（inline）汇编语言 268

第十章 使用Borland C++的高级功能 268

10.1.1 直接插入式汇编环境 269

10.1.2　使用asm关键字 271

10.2　与汇编语言子程序的接口 274

10.2.1 在C程序里调用汇编子程序 274

10.2.2 在汇编子程序中调用C函数 285

10.3　使用中断功能 293

10.3.1　80×86的中断结构 293

10.3.2　使用Borland的中断接口 295

10.4　使用中断处理程序 298

10.4.1 声明中断处理程序函数 298

10.4.2 实现一个时钟中断处理程序 300

10.5　练习 304

10.6　小结 305

11.1 C与C++派生类型的比较 306

第十一章　使用C++的类 306

第二部分 Borland C++面向对象的功能 306

11.1.1　在C++中重新定义“派生类型” 307

11.1.2　理解C++的封装（Encapsulation）概念 308

11.1.3　使用struct说明类 309

11.2　说明C++的类 313

11.2.1　理解类的说明 315

11.2.2　使用类说明的语法规则 316

11.2.3　说明类成员 319

11.2.4　建立后进先出的堆栈类 320

11.2.5　使用this指针 326

11.2.6　使用关键字public，private以及protected 332

11.3　编写类的成员函数 332

11.3.1　联系成员函数和类 333

11.3.1.1 分别编译成员函数 333

11.3.1.2　定义直接插入的成员函数 334

11.3.1.3　指定成员函数的缺省参数 335

11.3.2　提供构造函数和析构函数 336

11.4　使用友元函数 340

11.4.1　在类中包括友元函数 340

11.4.2　决定何时使用友元函数 341

11.5　练习 342

11.6　小结 342

第十二章　创建C++的对象 345

12.1 定义C++的对象 345

12.1.1 为类对象指定存储类 345

12.1.2 定义具有动态生存期的类对象 347

12.1.3　定义局部（auto）类对象 362

12.1.4　定义全局（静态）的类对象 370

12.2　初始化类对象 378

12.2.1 使用构造函数来初始化类对象 379

12.2.2　使用初始化表 381

11.3　练习 382

11.4　总结 382

第十三章　访问C++的对象 384

13.1 使用作用域限制操作符 384

13.1.1 作用域限制的一般用法 384

13.1.2　使用作用域限制进行语法控制 386

13.1.3　利用作用域限制来控制二义性 387

13.2　理解C++的作用域规则 391

13.2.1 理解C和C++作用域的不同 392

13.2 2 C++的作用域规则 393

13.3 C++的对象交流信息 396

13.3.1 向对象传送信息 396

13.3.2　理解＊this 420

13.4.1 由地址操作符进化而来的引用操作符 421

13.4.2　理解引用操作符 421

13 4 使用引用操作符 421

13.5　使用对象作为函数的参数 422

13.5.1 通过值和通过引用来传送对象 422

13.5.2　从成员函数中访问其它对象 424

13.6　使用指向对象的指针 425

13.6.1 理解何时需要指针 425

13.6.2 定义指向对象的指针和数组 426

13.7　练习 428

13.8　小结 428

第十四章　在C++中使用重载函数和操作符 430

14.1 重载成员函数 430

14.1.2　理解C++的重载 430

14.1.2　声明重载的成员函数 433

14.2 重载友元函数和非成员函数 435

14.2.1 重载类的友元函数 435

14.2.2　重载非成员函数 440

14.3　理解类型安全的连接 441

14.3.1 理解函数合并 441

14.3.2 利用标准C的包含文件来控制连接问题 443

14.4　在C++中重载操作符 445

14.4.1 理解操作符重载 446

14.4.2 声明重载操作符函数 451

14.4.2.1 定性地讨论操作符函数 451

14.4.2.2　理解重载操作符函数的语法规则 452

14.4.2.3　指定重载操作符函数的参数 454

14.4.2.4　指定操作符函数的返回类型 455

14.4.2.5 利用友元函数来重载操作符 456

14.4.2.6 定义强制类型转换操作符函数 459

14.4.3 重载双目操作符和单目操作符 460

14.5　重载下标操作符和函数调用操作符 461

14.5.1 使用重载的下标操作符 462

14.5.2 使用重载函数调用操作符 466

14.6　练习 470

14.7 小结 471

第十五章　使用C++的构造函数和析构函数 472

15.1 理解构造函数和析构函数调用 472

15.1.1 声明构造函数和析构函数 472

15.1.1.1 声明构造函数 473

15.1.1.2　声明析构函数 477

15.1.2　使用构造函数初始化 479

15.1.3　何时调用构造函数 482

15.1.4　何时调用析构函数 488

15.2　重载构造函数 492

15.3　写一个缺省构造函数 492

15.3.1 编写其它构造函数 494

15.3.2 决定何时需要一个拷贝构造函数 496

15.4.1 new和delete的使用 497

15.4　使用new（）操作符和delete（）操作符 497

15.4.2　动态地创建和删除类对象 499

15.5 重载操作符new（）和操作符delete（） 501

15.5.1 重载全局操作符 501

15.5.2　重载类的操作符 507

15.6 练习 509

15.7　总结 509

第十六章　使用C++流 511

16.1 C++流介绍 511

16.1.1 C++流与标准流的比较 512

16.1.2 使用C++流进行标准I/O 514

16.2　处理C++流的错误 522

16.2.1 检测C++流错误状态 523

16.2.2　使用流状态成员函数 525

16.3 用C++流控制数据格式 527

16.3.1 在内部类型中使用插入符和抽取符 527

16.3.2　重载＜＜和＞＞操作符 532

16.4　使用C++流操纵符（manipulators） 535

16.4.1 理解C++的操纵符 535

16.4.2 使用操纵符改变状态和属性 536

16.5 使用C++文件I/O流 544

16.5.1 读和写fstream文件 548

16.5.2 用C++流进行文件定位……………………………………………54？16.6　使用和转换旧式C++流 551

16.6.1 新旧C++流的区别 552

16.6.2 转化为新的C++流 553

16.7　练习 554

16.8　总结 555

第十七章　使用C++派生类 557

17.1 无继承性的代码重用 557

17.1.1 理解代码的重用性 557

17.1.2　通过组合重新使用代码 558

17.2.2 声明基本和派生类 561

17.2.1 理解继承 561

17.2　使用单个基类 561

17.3　一个实践项目：扩展内存支持 569

17.3.1 理解扩展内存规范（XMS） 569

17.3.2　建立XMS管理类 570

17.3.3　派生一个交换缓冲类 583

17.4　使用虚拟函数 588

17.4.1 使用迟后联编和虚拟函数 588

17.4.2　使用域限定控制符来控制成员函数的存取权限 592

17.5　使用多基类 592

17.5.1　从多个基类中派生 593

17.5.2 声明和使用虚拟基类 596

17.6　从抽象类中派生类 597

17.6.1　理解纯虚拟函数 598

17.6.2　纯虚拟函数的实现 598

17.7.1 初始化代码不能继承 599

17.7　在继承时使用构造函数和析构函数 599

17.7.2　理解在继承时调用构造函数和析构函数的顺序 600

17.7.3　使用虚拟析构函数 600

17.8　练习 602

17.9　小结 603

第十八章　对象控制、操作及将来发展方向 604

18.1 用户自定义类型转换 604

18.1.1 使用类的构造函数来进行类型转换 604

18.1 2　类型操作符的重载 606

18.2　使用generic类 609

18.2.1 理解抽象和generic类的设计 609

18.2.2　构造generic类 613

18.3　控制对象的行为与性能 620

18 3.1 使用友元函数以提高效率 620

18.3.2　使用友元函数来控制对象句法 621

18.3.3 使用静态存储类来避免重复创建 623

18.3.4 使用可引用量和指针 626

18.3.4 使用直接插入函数来消除函数调用 628

18.4　类对象控制中今后的发展方向 629

18.4.1 类和函数的模板 629

18.4.2　异常处理 630

18.5 练习 631

18.6 总结 631

第三部分　编写Windows应用程序 632

第十九章　使用Turbo Vision 632

19.1　Turbo Vision概述 632

19.1.1 何谓应用程序框架 632

19.1.2为何要使用Turbo Vision的应用程序框架 633

19.1.3 使用面向对象的代码的优点 633

19.1.4　事件驱动编程的优点 634

19.2.2.1 组 635

19.2.2　视口 635

19.2.1 事件 635

19.2　Turbo Vision应用程序概述 635

19.2.3　哑对象 636

19.3 编写第一个Turbo Vision应用程序 636

19.3.1 编写一个基本的Turbo Vision应用程序 636

19.3.2　增加菜单支持 638

19.4 使用Turbo Vision创建窗口 643

19.4.1 在Turbo Vision应用程序中增加窗口 643

19.4.2　在Turbo Vision窗口中增加文本 648

19.4.3 使用对话框窗口 652

19.5　练习 660

19 6 小结 660

第二十章 Borland C++高级编译器介绍 661

20.1 新的特征和功能 661

20.2.1 运行在MS-Windows下的程序员平台 663

20.2　运行的程序员平台 663

20.2.2　使用Borland C++的选项 665

20.3　Turbo Debugger 2.5 3.0 666

20.4　使用Turbo Debugger 2.5和3.0 667

20.4.1 影响TASM的C编译器的差异 667

20.4.2 支持Windows 3.0的新MODEL标识符 670

20.4.3 虚段支持 671

20.4.4 486指令集支持 671

20.4.5 RETCODE指令 672

20.4.6 TASMX.EXE和Windows DMPI 672

20.4.7　使用Whitewater资源开发工具 672

20.5　使用Resource Workshop 675

20.6　总结 687

第二十一章 使用Borland C++进行Windows程序设计 688

21.1 了解Windows程序设计环境 688

21.1.1　Windows是多任务环境 689

21.1.2　Windows环境是面向对象的环境 691

21.2　设置Borland C++以支持Windows应用程序设计 698

21.2.1 设置选择项以支持资源编译器和输入库管理器 698

21.2.1.1 只运行集成环境（IDE） 699

21.2.1.2　在Windows下运行集成环境（IDE） 699

21.2.2 为入口和出口代码设置编译器选项 700

21.3　使用WhiteWater资源工具箱（RT） 702

21.3.1　设置RT作为一个Windows程序项 703

21.3.2　fcwin.c程序需要的资源 703

21.3.3　运行RT 704

21.3.3.1 使用RT的主窗口 704

21.3.3.2　使用资源浏览器 705

21.3.3.3　建立和编辑图符 706

21.3.3.4　生成和编辑菜单 706

21.3.3.5　生成和编辑对话框 708

21.5　利用Borland的Resource Workshop绘制FCWIN资源 713

21.6　练习 721

21.7　总结 722

第二十二章　设计Windows应用程序 723

22.1 建立Windows应用程序环境 723

22.1.1 建立Windows承接程序可执行文件 723

22.1.2　了解Windows目录的用途 724

22.1.1.3　通过实践学习：设计fcwin.c 725

22.2　为Windows应用程序生成源文件 756

22.2.1　了解Windows 3.0程序设计环境 757

22.2.2　生成模块定义文件 757

22.2.3　设计程序的头文件 759

22.2.4　为FCWIN生成项目文件 760

22.3　练习 761

22.4　总结 761

23.1.2　注册窗口类 763

第二十三章　用Borland C++2.0写Windows应用程序 763

23.1　设计Windows界面 763

23.1.2　设置主消息循环 766

23.1.3　编写WndProc（）函数 767

23.1.4　为对话框设置回调函数 768

23.1.4.1 生成对话函数 769

23.1.4.2　控制对话框 770

23.1.5　为弹出帮助和出错信息使用MessageBox（） 771

23.1.6　Windows打印管理器的spooling硬拷贝 772

23.2　使用动态连接库 780

23.2.1 理解DLL 780

23.2.2 编写一个DLL应用程序 781

23.3 练习 785

23.4　总结 785

24.1 C++ ObjectWindows简介 786

第二十四章　使用ObjectWindows 786

24.1.1 在Windows程序中使用C++类 787

24.1.2 了解ObjectWindows库 800

24.1.3　编写第一个ObjectWindows程序 801

24.2　与基本Windows API函数和元素的接口 805

24.2.1 控制应用程序 806

24.2.2　控制窗口对象 807

24.2.3　控制Windows消息 809

24.3 练习 810

24.4 小结 811

附录A　ASCⅡ字符 812

附录B　使用printf（）和scanf（）的说明 815

附录C 使用exec...（）和spawn...（）的详细说明 826

附录D　quad类的程序清单 830

附录E CWIN资源的完整清单 843