后台开发：核心技术与应用实践

徐晓鑫　著

图书在版编目（CIP）数据

后台开发：核心技术与应用实践 / 徐晓鑫著. —北京：机械工业出版社，2016.8

ISBN 978-7-111-54339-8

I. 后…　II. 徐…　III. 网络－开发　IV. TP393.092

中国版本图书馆CIP数据核字（2016）第167884号

后台开发：核心技术与应用实践

出版发行：机械工业出版社（北京市西城区百万庄大街22号　邮政编码：100037）

责任编辑：李　艺责任校对：董纪丽

印　　刷：版　　次：2016年8月第1版第1次印刷

开　　本：186mm×240mm　1/16 印　　张：26.5

书　　号：ISBN 978-7-111-54339-8 定　　价：79.00元

凡购本书，如有缺页、倒页、脱页，由本社发行部调换

客服热线：（010）88379426　88361066 投稿热线：（010）88379604

购书热线：（010）68326294　88379649　68995259 读者信箱：hzit@hzbook.com

封底无防伪标均为盗版

本书法律顾问：北京大成律师事务所　韩光/邹晓东

Preface?序

C++可能是计算机历史上最早被发明的高级程序语言，同时也是当今最活跃的程序设计语言之一。C++很强大，强大到你可以使用它做任何层面的开发；C++也很脆弱，脆弱到需要程序员自己去控制内存回收，一个不小心就会使整个程序Core Dump。C++语言的创始人Bjarne Stroustrup曾私下承认，为了提高C++程序员的薪水和地位，在设计C++编译器版本过程中有意地增加了C++语言的难度，使C++更偏向于资深程序员的使用习惯，提高学习门槛，从而增加C++程序员的身价。学习曲线的增加并不是没有任何回报的，在服务端后台开发、处理多并发的海量网络请求方面，C++语言有天然的优势。因此，当应用的用户量、并发量迅速增长，达到一定量级之后，后端服务的技术架构都会转变为Linux C++。

要做一名优秀的使用C++进行后台开发的程序员，只掌握C++语言是远远不够的，还需要掌握如何进行编译、链接、调试，如何使用网络协议、IO模型和一些常用的类库，等等。我曾经面试过不少后台开发程序员，他们往往很重视语言本身，但是对一些语言之外的东西理解不够透彻，影响了他们的技术发展。我也读过不少相关方面的技术书籍，往往都过多地停留在语言层面，忽略了实际开发工作中需要用到的知识。

晓鑫在腾讯从事开发工作多年，有丰富的后台开发经验，她从实际的后台开发经验出发，讲解了后台开发中需要用到的方方面面的知识。从C++语言出发，又不止于C++语言，本书可以说是一本Linux C++后台开发的实战典范。当知道晓鑫在写这么一本书的时候，我真心为国内的众多开发者感到高兴。如果读者有意愿成为一名从事Linux后台开发的程序员，本书无疑是一本最佳的参考书籍。

研发是一项讲究实战的工作，一切不从实际工作出发的技术书籍都是纸上谈兵，没有实际意义。一本优秀的技术书籍应该是这样的：当读者按照书中的内容进行实操的时候，读者写的每一行代码都是有价值的，能够在实际工作中派上用场。本书恰好做到了这一点。这是一位技术书籍作者对读者的起码诚意。

软件工程师是一种需要坚定、踏实、精益求精的“工匠精神”的职业，心浮气躁、得过且过的态度不可能把代码写好。老一辈的人说“字如其人”，在软件领域，我们同样可以说“代码如其人”，一个人的行事风格和为人态度都会体现到他所写的代码上面。按照晓鑫的书去学习，读者可以潜移默化地学习到她多年后台开发所炼就的“工匠精神”。我想，相对于所学习到的知识，这于一个工程师来说更为重要。

黄世飞

腾讯云平台技术总监

Introduction?绪　　论

0.1　什么是后台开发

听到“后台开发”这个词，估计读者心中都或多或少会有一些自己的感性认识，这种认识可能有一些差别，但估计大部分人都有这么一种看法：“后台开发”是编写一些用户看不见的程序，也就是非界面的程序，既不是网页，也不是App，更不是桌面程序，因为这些都是用户看得见的（被称为“前台开发”）。这种感性认识在一定程度上是正确的，但是它不够具体，也不够全面。

我们这里所说的“后台开发”的确是用户“看不见”的部分，但是还有很多界面性的程序是给企业内部人员使用的，这些虽然是界面程序，但是对于最终用户来说也是“看不见”的。举个例子，开发一个电子商务网站，提供给客户进行商品购买的网页是用户看得见的，不属于“后台”，但是电商网站内部员工使用的“用户管理系统”，“订单管理系统”等，也是用户看不见的，但它们不属于本书中所指的“后台”。在某些场合，或者某些人的习惯中，这些内部使用的系统也叫“后台”，这几种说法都没有错，希望读者在听到的时候，知道说话人具体指的是什么。

本书介绍的“后台开发”指的是“服务端的网络程序开发”，从功能上可以具体描述为：服务器收到客户端发来的请求数据，解析请求数据后处理，最后返回结果，如图0-1所示。

图0-1　后台开发的步骤

这里的SERVER就是本书所指的“后台程序”，或者“服务器”。SERVER接收请求的方式既可以是通过TCP请求包，也可以是HTTP请求包（其实也是TCP连接）。如果是TCP请求，二进制的格式会常见一些；如果是HTTP方式的请求，请求包的格式一般是JSON或者XML，或者自定义的ASCII文本。解析请求包的方式自然是与请求包的格式相对应的，接收到的是什么格式的包，就用对应的格式解析（如果是自定义的格式，就按照自定义的方式去解析）。“处理请求”这一步是后台程序的具体业务逻辑的体现。很多封装好的后台框架会把其他三步都做好，但是这一步还是需要开发者自己去实现，因为只有开发者自己清楚，程序是要去做“登录”还是去做“注册”的事情。“输出回复包”和“接收请求包”是对应的，一般来说，收到的是JSON，那么回复的也是JSON，收到的是XML，那么发送的也是XML，其他格式也是一样的。这四个步骤是所有后台程序都会有的，无论使用什么语言去实现，都可以看到这四个步骤的影子。

CLIENT指的是向SERVER发起请求，并接收SERVER回复的一方，通常称为“客户端”。既然后台程序是通过TCP或者HTTP接收和回复消息的，那么只要是能够发起TCP或者HTTP连接的都可以作为客户端，可以是浏览器、PC端的程序、安卓应用、IOS应用，等等。

0.2　时间就是金钱，效率就是生命

上世纪80年代，在改革开放初期的深圳蛇口，为了加快蛇口港的建设，一块“时间就是金钱，效率就是生命”的巨幅标语矗立在蛇口工业区的马路边（如图0-2所示），拉开了特区建设的序幕。

图0-2　1981年矗立在深圳蛇口工业区的巨幅标语

其实这个口号后面还有两句：“安全就是法律，顾客就是皇帝”，这四句加一起，简直就是当今互联网时代科技公司安身立命的根本。互联网最讲究效率并且一切都从用户体验出发。在腾讯、百度和阿里这样的互联网公司里，每一次的版本发布都是和时间在赛跑。各种以效率为核心的开发团队合作模式被创造：敏捷开发、极限编程、SCRUM、结对编程，双周迭代，等等。

写下这些文字的时候是我在腾讯工作的第五个年头，这五年让我对效率有了更深刻的认识。还是一个学生的时候，和大家一样，我也曾一字不落地读过《UNIX环境高级编程》，《UNIX环境网络编程》一二三卷，《TCP/IP详解》一二三卷，《C++ Primer》等书籍，这些都是非常经典的开发书籍。它们的共同特点是大而全，不漏掉任何一个知识点，并且每个知识点都讲得非常详细。但在实际的开发工作中，可能用到的知识点只有20%，其他的80%则很少用到。这也是我写这本书的初衷：用最短的篇幅，讲解实际后台开发中用到的核心知识点，让读者可以快速进入到实际的开发工作中。

也许有读者会觉得这很急功近利，不利于组建完整的知识体系。其实，软件开发是一门讲究实操的技术，知道多少并不重要，重要的是能够用好多少。如果把一本经典书籍读3遍，但是没有写过一行代码，那可以认为是没有读。边写代码边读书才是最好的学习方式，在读一本技术书籍的时候，最好让自己快速进入写代码的状态，一边写代码，一边通读书籍，在具体需要用到书上某个技术点的时候，再回头仔细阅读相关的章节。在这个循环往复的过程中，才能把书上的知识点转化为自己的知识点。完成多个这样的循环后，再回过头来审视自己已经掌握的知识点，把一些没有掌握的知识点搞清楚。这样的学习过程实际上更有利于完善自己的知识体系。

0.3　后台开发的知识体系

接下来简单介绍一下后台开发的知识体系，也就是说，要完整掌握后台开发，需要掌握哪些知识点，这些知识点也是本书会讲解到的知识点。图0-3展示了对后台开发知识体系一个比较全面的梳理。

以上这六部分知识点会是本书将会覆盖的内容。与专门介绍某一类知识的书籍不同，比如《C++ Primer》介绍C++的方方面面，《UNIX环境编程》介绍UNIX环境编程的方方面面，本书从“实战”的角度出发，介绍“后台开发”需要用到的知识和工具。读完本书，读者可能不会对C++精通，不会对Linux精通，也不会对TCP/IP精通，但是却可以学会如何进行“后台开发”，这些“精通”可以一个个慢慢补全。

图0-3　后台开发工程师技术能力体系图

细心的读者可能会发现，编程语言和编辑器只是其中的一小部分，要把后台开发做好，需要掌握的东西比想象中的要多。同时，这些知识点既有一些纯理解性的内容，也有一些工具性的东西。这也是程序开发的最大特点，既要掌握理论的东西，也要掌握相应的工具，这样才能把理论的知识用起来。在实际开发中，这些工具性的知识可能更重要，因为理论是脑子里想的，但工具产生的东西才是真正的产出，才是开发者最终需要的。

0.4　如何阅读本书

本书以C++为编程语言，讲述后台开发的核心技术与应用实践。全书共13章，在逻辑上分为以下六部分：

第一部分为第1～3章，主要是编程语言方面的知识，包括函数、函数重载、函数模板、数组、指针、引用、结构体和预处理的使用；面向对象的介绍，包括类的使用、继承与派生和类的多态；常用STL的介绍，包括string、vector、map和set的使用方法与原理。如果读者已经对C++非常了解，可以跳过这部分，也可以配合《C++ Primer》一起阅读。

第二部分为第4～5章，主要是编译原理和调试方法相关的知识。编译原理相关知识包含编译与链接的具体过程，makefile的编写、目标文件的内容与处理目标文件相关工具的使用；调试方法相关内容主要介绍了用strace分析系统调用、用gdb调试进程与分析coredump文件、用top命令分析系统负载情况、用ps命令查看系统进程和用valgrind工具分析进程的内存使用情况等。

第三部分为第6～8章，主要是网络相关的知识，包括TCP协议的关键知识点和TCP server的实现，网络IO模型和select、poll与epoll三个重要函数的使用，还有ping、tcpdump、netstat和lsof这四个网络分析工具的使用。掌握这部分知识，读者可以自己独立实现能处理海量请求的TCP server。

第四部分为第9～11章，主要是多线程、进程和进程间通信相关的知识，包括多线程的使用、多线程的同步和重入问题，父子进程、僵尸进程、守护进程和进程间通信的方式。读者可以配合《UNIX环境高级编程》一起阅读。

第五部分是第12章，主要是HTTP协议的介绍与使用、CGI的设计原理与实现和FASTCGI的简单介绍。掌握这部分知识，读者可以轻松实现Web应用的后台交互部分。

第六部分是第13章，通过常用类库JsonCPP和Protobuf的使用，演示如何使用第三方库。

如果读者是后台开发的新手，建议从第1章开始阅读，如果读者已经有后台开发的经验，可以直接选择感兴趣的章节阅读。

0.5　勘误和资源

由于水平有限，加之编写时间仓促，书中难免会出现一些错误或者不准确的地方，恳请读者批评指正。为了更好地与读者交流，我专门创建了一个微信公众号，读者可以通过以下二维码关注，与我进行交流。

书中的全部源代码可以从华章网站（www.hzbook.com）下载。

0.6　致谢

首先要感谢腾讯公司，让我可以在后台开发的领域里驰骋。

其次要感谢机械工业出版社华章公司的杨福川、高婧雅和李艺，感谢你们在我写作过程中提供的支持，因为有了你们的鼓励和帮助，我才能顺利完成全部书稿。

谨以此书献给我亲爱的家人，以及热爱软件开发的朋友们！

Contents?目　　录

序

绪论

第1章　C++编程常用技术 1

1.1　第一个C++程序 1

1.2　函数 3

1.3　数组 6

1.4　指针 8

1.5　引用 12

1.6　结构体、公用体、枚举 14

1.6.1　结构体、共用体、枚举的概念 14

1.6.2 结构体、共用体在内存单元占用字节数的计算 18

1.7　预处理 20

1.8　本章小结 25

第2章　面向对象的C++ 26

2.1　类与对象 26

2.2　继承与派生 49

2.3　类的多态 57

2.4　本章小结 64

第3章　常用STL的使用 65

3.1　STL是什么 65

3.2　string 66

3.3　vector 77

3.3.1　vector是什么 77

3.3.2　vector的查增删 78

3.3.3　vector的内存管理与效率 86

3.3.4　Vector类的简单实现 90

3.4　map 96

3.4.1　map是什么 96

3.4.2　map的查增删 96

3.4.3　map的原理 109

3.5　set 111

3.5.1　set是什么 111

3.5.2　set的查增删 112

3.6　本章小结 116

第4章　编译 117

4.1　编译与链接 117

4.2　makefile的撰写 131

4.3　目标文件 135

4.3.1　ELF的文件类型 135

4.3.2　链接视图下的ELF内容 136

4.3.3　执行视图下的ELF内容 142

4.3.4 阅读ELF文件的工具——readelf 144

4.3.5 获得二进制文件里符号的工具——nm 144

4.3.6 减少目标文件大小的工具——strip 146

4.4　本章小结 147

第5章　调试 148

5.1　strace 148

5.2　gdb 156

5.3　top 164

5.4　ps 165

5.5　Valgrind 168

5.5.1　Valgrind概述 168

5.5.2　Linux程序内存空间布局 170

5.5.3　内存检查原理 175

5.5.4　Valgrind安装 176

5.5.5　Valgrind使用 177

5.6　本章小结 187

第6章　TCP协议 188

6.1　TCP协议 188

6.1.1　网络模型 188

6.1.2　TCP头部 191

6.1.3　TCP状态流转 193

6.1.4　TCP超时重传 196

6.1.5　TCP滑动窗口 200

6.1.6　TCP拥塞控制 202

6.2　TCP网络编程API 205

6.3　实现一个TCP server 211

6.4　TCP协议选项 215

6.5　网络字节序与主机序 233

6.6　封包和解包 233

6.7　本章小结 247

第7章　网络IO模型 248

7.1　4种网络IO模型 248

7.2　select 256

7.3　poll 267

7.4　epoll 277

7.5　本章小结 289

第8章　网络分析工具 290

8.1　ping 290

8.2　tcpdump 292

8.3　netstat 294

8.4　lsof 296

8.5　本章小结 298

第9章　多线程 299

9.1　多线程是什么 300

9.2　多线程的创建与结束 301

9.3　线程的属性 307

9.4　多线程同步 312

9.5　多线程重入 332

9.6　本章小结 333

第10章　进程 334

10.1　程序与进程 334

10.2　进程的创建与结束 335

10.3　僵尸进程 342

10.4　守护进程 347

10.5　本章小结 351

第11章　进程间通信 352

11.1　管道 352

11.2　消息队列 358

11.3　共享内存 362

11.4　信号量 368

11.5　ipcs命令 373

11.6　本章小结 374

第12章　HTTP协议 375

12.1　HTTP协议工作流程 375

12.2　HTTP协议结构 376

12.3　HTTPS 383

12.4　CGI 386

12.5　FastCGI 397

12.6　本章小结 398

第13章　常用类库 399

13.1　JSON 400

13.2　Protobuf 405

13.3　本章小结 409

第1章

C++编程常用技术

我们通过固定格式和固定词汇的“语言”来影响他人，让他人为我们做事情。语言有很多种，包括汉语、英语、法语、韩语等，虽然它们的词汇和格式都不一样，但是可以达到同样的目的，我们可以选择任意一种语言去与他人交流。同样，我们也可以通过“语言”来影响计算机，让计算机为我们做事情，这样的语言就叫作编程语言。

C语言是1972年由美国贝尔实验室的D.M.Ritchie设计成功的，它是为计算机专业人员设计的，大多数系统软件和许多应用软件都是用C语言编写的。但是随着软件规模的增大，用C语言编写程序渐渐显得有些吃力了。C++也是由美国贝尔实验室的Bjarne Stroustrup博士及其同事于20世纪80年代初在C语言的基础上开发成功的。C++保留了C语言原有的所有优点，与C语言兼容，并且增加了面向对象的机制。用C语言写的程序基本上可以不加修改地用于C++开发工具。从C++的名字可以看出它是C的超集。C++既可用于面向过程的结构化程序设计，又可用于面向对象的程序设计，是一种功能强大的混合型程序设计语言。

本章主要讲述C++中的常用技术，让读者可迅速地、由浅入深地熟悉这门语言。

1.1　第一个C++程序

刚开始接触一门编程语言，一般会从写一个输出Hello world的程序开始。

【例1.1】　用程序输出Hello world。

#include<iostream>

using namespace std;

int main()

{

cout<<"Hello world."<<endl;

return 0;

}

把上述程序编写在一个叫helloworld.cpp的文件中，并将它放到Linux机器上的某个目录下，执行g++ helloworld.cpp命令，会在该目录下生成a.out文件。执行./a.out命令，即可得到输出结果：Hello world.。

先看程序的第一行（#include<iostream>），这不是一个C++语句，是一个预处理语句，编译器的预处理器把输入输出流的标准头文件包括在本程序中，所以不需要在句末加分号（；）。include一个文件，就是把这个文件的所有内容都加进来。图1-1展示了包含文件的过程。

如图1-1所示，include一个.h文件，就是等于把整个.h文件给复制到程序中，include一个.cpp文件也是如此。

除了#include< >的方式来包含一个头文件，还会见到#include" "的方式来包含一个头文件。而#include< >与#include" "的区别是：#include< >常用来包含系统提供的头文件，编译器会到保存系统标准头文件的位置查找头文件；而#include" "常用于包括程序员自己编号的头文件，用这种格式时，编译器先查找当前目录是否有指定名称的头文件，然后从标准头目录中进行查找。

还经常会看到#include<iostream>和#include<iostream.h>的使用。事实上，#include<iostream>和#include<iostream.h>是不一样的，因为iostream和iostream.h是两个不同的文件，前者没有后缀。实际上，在你的编译器include文件夹里面可以看到，两个文件打开后，里面的代码是不一样的。后缀为.h的头文件在C++标准已经明确提出不再支持了，早些的C语言为了实现将标准库功能定义在全局空间里，声明放在在带.h后缀的头文件里。C++标准为了和C语言区别开，也为了正确使用命名空间，规定头文件不再使用后缀.h。因此，当使用<iostream.h>时，相当于在C中调用库函数，使用的是全局命名空间，也就是早期的C++实现方法。换句话说，iostream是iostream.h的升级版，大部分的头文件都有一个不带.h扩展名的文件与之相对应。不过有个特例，<string>并非<string.h>的升级版。

再看程序的第二行：“using namespace std;”中使用了命名空间std。命名空间是为了让大量类名共存而不至于引起冲突而设计的。C++标准函数库的所有元素都被声明在一个命名空间中，这就是std命名空间。为了能够访问它的功能，使用这条语句来表达将使用标准名空间中定义的元素。这条语句在使用标准函数库的C++程序中频繁出现，本书中大部分例子的代码中也将用到它，需要注意的是，最好不要在头文件中使用命名空间，否则容易造成命名冲突。

继续看程序的第三行：“int main()”，这是主函数(main function)的起始声明。主函数是所有C++程序的运行的起始点。不管它是在代码的开头、结尾还是中间，此函数中的代码总是在程序开始运行时第一个被执行。main后面跟了一对圆括号()，表示它是一个函数。C++中所有函数都跟有一对圆括号()，括号中可以有一些输入参数。如例1.1中显示，主函数(main function)的内容紧跟在它的声明之后，由花括号{}括起来。

程序的第四行：“cout<<"Hello world."<<endl;”是本程序中最重要。cout是C++中的标准输出流（通常为控制台，即屏幕），这句话把一串字符串（本例中为Hello World）插入到输出流中。cout在的声明在头文件iostream中，所以要想使用cout必须将该头文件包括在程序开始处。注意这个句子以分号结尾。分号标示了一个语句的结束，C++的每一个语句都必须以分号结尾。C++程序员最常犯的错误之一就是忘记在语句末尾写上分号。

最后一行(return 0;)中返回语句(return)标志主函数main()执行结束，并将该语句后面所跟代码（在本例中为0）返回。这是在程序执行没有出现任何错误的情况下最常见的程序结束方式。在后面的例子中会看到所有C++程序都以类似的语句结束。

1.2　函数

1.?函数的定义

一个C程序是由若干个函数组成的，C语言被认为是面向函数的语言，而C++面向过程的程序设计也沿用了C语言使用函数的方法。在C++面向对象的程序设计中，主函数以外的函数大多是被封装在类中的。主函数或其他函数可以通过类对象调用类中的函数。无论是C还是C++，程序中的各项操作基本上都是由函数来实现的，程序编写者要根据需要编写一个个函数，每个函数用来实现某一功能。因此，读者必须掌握函数的概念以及学会使用和设计函数。

定义函数的一般格式是：

返回值类型函数名([形参])

{

函数体

}

在定义函数时函数名后面括号中的变量名称是形参。在主调中调用一个函数时，函数名后面括号中的参数是实参。

【例1.2】　函数、形参、实参的使用举例。

#include<iostream>

using namespace std;

int min(int a,int b){ // 这里的min就是函数名，a、b是形参，

// 返回值是一个int整型

if(a<b)return a;

else return b;

}

int main(){

int a=10,b=1;

cout<<min(a,b)<<endl; // 这里的a、b是实参

return 0;

}

函数的执行结果是：

例1.2中定义了一个函数，有2个整型的参数，且返回值是整型的，在main函数中调用min函数时，传入的是实参。

形参与实参的区别是：形参只有被调用时才分配内存单元，在调用结束时，立即释放所分配的内存单元。实参与形参的类型应相同或赋值兼容。

2.?函数重载

C++允许用同一函数名定义多个函数，但这些函数必须参数个数不同或类型不同，这就是函数重载。例1.3说明了函数重载的使用方法。

【例1.3】　求不同类型的数中的最小者。

#include<iostream>

using namespace std;

int min(int a, int b, int c){

if(a>b)a=b;

if(a>c)a=c;

return a;

}

long long min(long long a,long long b, long long c){

// 与上面那个函数的差别是参数的类型不同

if(a>b)a=b;

if(a>c)a=c;

return a;

}

double min(double a, double b){ // 这个函数与以上的差别是只有2个参数

if(a-b>(1e-5))a=b;

return a;

}

int main(){

int a=1,b=2,c=3;

cout<<min(a,b,c)<<endl;

long long a1=100,b1=200,c1=300;

cout<<min(a1,b1,c1)<<endl;

double a2=1.1,b2=2.2;

cout<<min(a2,b2)<<endl;

return 0;

}

程序的执行结果是：

100

1.1

这里分别需要比较3个整数、3个长整数和2个浮点数，并获得各组中的最小值。例1.3中分别定义了3个函数，而且函数名都是一样的，不过参数个数不一样或者参数类型不一样，这就是使用了函数重载来实现功能。

在使用函数重载时，同名函数的功能应当相同或相近，不要用同一函数名去实现几个完全不相干的功能，这样虽然程序能运行，但是可读性不好，会让人觉得莫名其妙。

3.?函数模板

函数模板，实际上是建立一个通用函数，其函数类型和形参不具体指定，而用一个虚拟的类型来代表，这个通用函数就是函数模板。凡是函数体相同的函数都可以用这个模板来代替，而不用定义多个函数，实际使用时只需在模板中定义一次就可以了。在调用函数时，系统会根据实参的类型来取代模板中的虚拟类型，从而实现不同函数的功能。

定义函数模板的一般格式是：

template<typename T>

下面的程序说明了函数模板的使用方法。

【例1.4】　函数模板使用举例。

#include<iostream>

using namespace std;

template<typename T>

T min(T a,T b,T c){

if(a>b)a=b;

if(a>c)a=c;

return a;

}

int main(){

int a=1,b=2,c=3;

cout<<min(a,b,c)<<endl;

long long a1=1000000000,b1=2000000000,c1=3000000000;

cout<<min(a1,b1,c1)<<endl;

return 0;

}

程序输出结果：

1000000000

例1.4中定义了一个函数模板，用来获得3个数中的最小者。若传入3个整型的，函数就将虚拟类型T转成int去执行；若传入3个长整型的，函数就将T转化成long long去执行。这样就可以不用定义类型不同的函数了，只需一个函数模板即可搞定。

在编写函数模板时，可以先写一个函数，然后把其中的变量类型都替换成虚拟类型即可。可以看到，用函数模板比函数重载更方便，但是它只适用于函数个数相同而类型不同的情况。

1.3　数组

1.?数组的定义

数组是相同类型数据的集合。引入数组就不需要在程序中定义大量的变量，大大减少程序中变量的数量，使程序精炼，而且数组含义清楚，使用方便，明确地反映了数据间的联系。许多好的算法都与数组有关。熟练地利用数组，可以大大地提高编程的效率，加强程序的可读性。例1.5展示了数组的使用方法。

【例1.5】　一维数组与二维数组使用举例。

#include<iostream>

using namespace std;

int main(){

int a[10]={1,2,3,4,5,6,7,8,9,10};

// 数组a,类型为int整型，有10个元素，是一个一维数组

int i,j;

for(i=0;i<10;i++){ // 从a[0]~a[9]

cout<<a[i]<<" ";

}

cout<<endl;

int b[2][2]={1,2,3,4}; // 数组b，类型为int，有4 元素，是一个二维数组

for(i=0;i<2;i++){

for(j=0;j<2;j++){

cout<<b[i][j]<<" ";

}

cout<<endl;

}

return 0;

}

程序的执行结果是：

1 2 3 4 5 6 7 8 9

1 2

3 4

例1.5中数组a是一个一维数组，有一个下标；数组b是一个二维数组，有两个下标。

一个数组在内存中占用的存储单元是连续的，也就是说一个数组在内存中占用一片连续的存储单元。在32位的机器上，一个int类型的值占4Byte，如果a[0]的地址是2000，那么a[1]的地址就是2004，a[2]的地址就是2008，a[3]的地址就是2012……如此类推。这里的“地址”，大家可以简单理解为在内存中的一个标识，详细内容会在本章的1.4节中进行介绍。

2.?字符数组

字符数组，就是一个用来存放字符数据的数组，示例如下：

char str[10]="Book";

其中，str就是一个字符数组，并且str[0]='B'，str[1]='o'，str[2]='o'，str[3]='k'。C++中用'\0'来标识一个字符串的结束，这里，str[4]~str[9]都是'\0'。通常用strlen()函数来计算一个字符串的长度，故strlen(str)的值是4。与strlen()函数比较容易混淆的是sizeof()函数，这里sizeof(str)的值是10。

strlen与sizeof的区别如下所示：

（1）strlen()是函数，在运行时才能计算。参数必须是字符型指针（char*），且必须是以'\0'结尾的。当数组名作为参数传入时，实际上数组已经退化为指针了。它的功能是返回字符串的长度。

（2）sizeof()是运算符，而不是一个函数，在编译时就计算好了，用于计算数据空间的字节数。因此，sizeof不能用来返回动态分配的内存空间的大小。sizeof常用于返回类型和静态分配的对象、结构或数组所占的空间，返回值跟对象、结构、数组所存储的内容没有关系。

当参数分别如下时，sizeof返回的值表示的含义如下所述。

1）数组——编译时分配的数组空间大小，如：

char a[10]="hello";

因为char占1Byte，所以sizeof(a)的值是10*1=10Byte。

2）指针——存储该指针所用的空间大小，如：

char *str="I am from China."

因为str存储的是一个字符指针，所以sizeof(str)是指针所占的空间，即是4Byte。

3）类型——该类型所占的空间大小，如：

int b=10;

因为在32位的机器上，int类型占4Byte，所以sizeof(b)的值是4Byte。

4）对象——对象的实际占用空间大小，如：

class Class_Sample{

int a,b;

int func();

}Class_a;

两个int类型的值是8Byte，所以sizeof(Class_a)的值是8Byte。

5）函数——函数的返回类型所占的空间大小，且函数的返回类型不能是void。

1.4　指针

1.?指针的概念

为了理解什么是指针，必须先弄清楚数据在内存中是如何存储的，又是如何读取的。如果在程序中定义了一个变量，在编译时就给这个变量分配内存单元。系统根据程序中定义的变量类型，来分配一定长度的空间。例如，C++编译系统在32位机器上为整型变量分配4Byte，为单精度浮点型变量分配4Byte，为字符型变量分配1Byte。内存区的每一个字节有一个编号，这个编号就是地址，如表1-1所示。

表1-1　用户数据、变量、地址直接的对应关系

地址用户数据变量名

… … …

2000 3 变量i

2004 6 变量j

2008 9 变量k

2012 10 变量l

… … …

表1-1中展示了用户数据、变量、地址直接的对应关系。假设有变量i，存的数据是3，那它在内存中的地址就是2000。

请务必弄清楚一个内存单元的地址与内存单元的内容这两个概念的区别。其实程序经过编译以后已经将变量名转换为变量的地址，对变量值的存取都是通过地址进行的。这种按变量地址存取变量值的方式称为直接存取方式，或直接访问方式。还可以采用另一种称为间接存取（间接访问）的方式，在程序中定义一种特殊的变量，专门用来存放地址。

由于通过地址能找到所需的变量单元，因此可以说，地址指向该变量单元。因此将地址形象化地称为“指针”，一个变量的地址称为该变量的指针。如果有一个变量是专门用来存放另一变量地址（即指针）的，则它称为指针变量。指针变量的值（即指针变量中存放的值）是地址（即指针）。

指针也是一种变量，普通的变量存放的是实际的数据，而指针变量包含的是内存中的一块地址，这块地址指向某个变量或者函数。指针的内容包括：指针的类型、指针所指向的类型、指针的值以及指针本身所占的内存区。例1.6展示了指针的使用。

【例1.6】　指针使用举例。

#include<iostream>

using namespace std;

int main(){

int p1=1; // p1是一个普通的整型变量

int *p2; // p2是一个指针，指向一个整型变量

p2=&p1; // 把p1的地址赋值给p2，p2也就指向了p1

cout<<p1<<" "<<*p2<<endl; // *p2就是取p2所指向的地址的内容

p1=2; // 那么*p2的值也是2

cout<<p1<<" "<<*p2<<endl;

*p2=3; // 那么p1的值也是3

cout<<p1<<" "<<*p2<<endl;

return 0;

}

程序的执行结果是：

1 1

2 2

3 3

例1.6中定义了一个整型变量p1，一个指向整型变量的指针p2，并将p2指向p1。要使用p2指向的内容，必须在p2前面加个*号，也就是*p2。修改了p1的值，*p2的内容也会跟着改变；同样地，修改*p2的值，p1的值也会跟着改变。

2.?数组与指针

在C++中，数组名代表数组第一个元素的地址，如下程序定义了两个变量：

int *p;

int a[10];

若p=a等价于p=&a[0]，可以通过对p、a的偏移（int类型的指针+1或-1，是向上或向下偏移sizeof(int)个byte）来访问数组里的元素，若用*(p+i)、*(a+i)也可以通过传统的数组a[i]访问各个元素。

（1）数组指针，也称行指针，具体内容如下所述。

假设有定义int (*p)[n];且()优先级高，首先说明p是一个指针，且指向一个整型的一维数组。这个一维数组的长度是n，也可以说是p的步长，也就是说执行p+1时，p要跨过n个整型数据的长度。如要将二维数组赋给一指针，应这样赋值：

int a[3][4];

int (*p)[4]; // 该语句是定义一个数组指针，指向含4个元素的一维数组。

p=a; // 将该二维数组的首地址赋给p，也就是a[0]或&a[0][0]

p++; // 该语句执行过后，也就是p=p+1;p跨过行a[0][]指向了行a[1][]

// 所以数组指针也称指向一维数组的指针，亦称行指针。

（2）指针数组不同于数组指针，具体内容如下所述。

假设有定义int *p[n];且[]优先级高，可以理解为先与p结合成为一个数组，再由int*说明这是一个整型指针数组，它有n个指针类型的数组元素。这里若执行p+1操作则是错误的，p=a这样赋值也是错误的，因为p是个不可知的表示，只存在p[0]、p[1]、p[2]...p[n-1]，而且它们分别是指针变量，只用来存放变量地址。但可以这样*p=a赋值这里*p表示指针数组第一个元素的值，a的首地址的值。

如要将二维数组赋给一指针数组，程序可以是：

int *p[3];

int a[3][4];

for(i=0;i<3;i++){

p[i]=a[i];

}

这里int *p[3]表示一个一维数组内存放着3个指针变量，分别是p[0]、p[1]、p[2]，所以要分别赋值。

这样数组指针和指针数组两者的区别就很明显了：数组指针只是一个指针变量，可以认为是C语言里专门用来指向二维数组的，它占用内存中一个指针的存储空间；指针数组是多个指针变量，以数组形式存在内存当中，占用多个指针的存储空间。还需要说明的一点就是，同时用来指向二维数组时，其直接引用和用数组名引用都是一样的。

比如要表示数组中第i行j列一个元素，这几种方式都可以：

*(p[i]+j)、*(*(p+i)+j)、(*(p+i))[j]、p[i][j]。

其中，优先级：()>[]>*。

3.?字符串与指针

字符串是C++中最经常用到的操作对象之一。用字符数组和字符指针变量都可以实现字符串的存储和运算。例1.7展示了字符数组和字符指针是如何使用的。

【例1.7】　字符数组、字符指针、字符指针数组、字符串变量应用举例。

#include<iostream>

#include<string>

using namespace std;

int main(){

char str[] = "I am a programmer." ; // str 是一个字符数组

char * str1="abc"; // str1是一个字符指针变量，可以指向一个字符串

char * str2[]={"hello world","good bye"};

// str2是一个字符指针数组，可以存多个字符串

string str3 = "I am a programmer, too.";

// str3是一个字符串变量

cout<<"str: "<<str<<endl;

cout<<"str1: "<<str1<<endl;

cout<<"str2[0]: "<<str2[0]<<endl;

cout<<"str3: "<<str3<<endl;

return 0;

}

程序的执行结果是：

str: I am a programmer.

str1: abc

str2[0]: hello world

str3: I am a programmer, too.

例1.7中，str是一个字符数组，str1是一个字符指针变量，str2是一个字符指针数组，str3是一个字符串变量。

（1）字符串指针变量本身是一个变量，用于存放字符串的首地址。可以改变str1使它指向不同的字符串，但不能改变str1所指的字符串常量。因为定义指针时，编译器并不为指针所指向的对象分配空间，它只是分配指针本身的空间，所以abc会被当成常量，并且被放到程序的常量区，不能被修改。

（2）字符串本身是存放在以该首地址为首的一块连续的内存空间中，并以'\0'作为字符串的结束标志。

（3）字符数组是由于若干个数组元素组成的，每个元素中存放字符串的一个字符。在定义一个字符数组时，编译后就会分配一个内存单元，每个元素都有确定的地址。

4.?函数与指针

函数指针是指向函数的指针变量。所以，函数指针首先是个指针变量，而且这个变量指向一个函数。C++在编译时，每一个函数都有一个入口地址，该入口地址就是函数指针所指向的地址。有了指向函数的指针变量后，就可以用该指针变量调用函数了。

函数指针的声明方法是：

返回值类型 (*指针变量名)([形参列表]);

其中，返回值类型说明函数的返回值类型，（*指针变量名）这句的括号不能省略。

例如：

int func(int a); // 声明一个函数

int (*f) (int a); // 声明一个函数指针

f=&func;

将func函数的首地址赋值给函数指针，这里也等价于f=&func；赋值时函数不带括号，也不带参数，函数名就代表了函数的首地址。例1.8展示了函数指针调用函数的方法。

【例1.8】　函数指针使用范例。

#include<iostream>

using namespace std;

int Mmin(int x,int y){

if(x<y)return x;

return y;

}

int Mmax(int x,int y){

if(x>y)return x;

return y;

}

int main(){

int (*f)(int x,int y);

int a=10,b=20;

f=Mmin; // 把Mmin函数的入口地址赋给f

cout << (*f)(a,b)<<endl;

f=Mmax; // 把Mmax函数的入口地址赋给f

cout << (*f)(a,b)<<endl;

return 0;

}

程序的执行结果是：

例1.8中定义了一个函数指针f，两个函数Mmin和Mmax，先后把f指向Mmin和Mmax函数，执行比较两个数，分别得出较小值和较大值。

1.5　引用

1.?引用是什么

对于习惯使用C语言进行开发的朋友们，在看到C++中出现的&符号后，可能会犯迷糊，虽然在C语言中这个符号代表取地址符，但是在C++中它却有着不一样的用途，代表着引用的意思。掌握C++的&符号，有利于增强代码质量和提高代码执行效率。

引用是一种变量类型，它用于为一个变量起一个别名。

引用的声明方法是：

类型标识符 &引用名=目标变量名;

假设有一个变量a，想给它起一个别名r，可以这样写：

int a;

int &r=a;

定义引用r，它是变量a的引用，即别名。经过这样的声明后，a和r的作用都一样，都代表着同一变量。a和r占用内存的同一个存储单元，即具有同一地址。在声明一个引用变量时，必须同时使之初始化，即声明它代表哪个变量。函数执行期间，不可以将其再作为其他变量的引用。例1.9说明了引用的使用方法。

【例1.9】　引用的使用举例。

#include<iostream>

using namespace std;

int main(){

int a=2;

int &r=a;

a=a+4;

cout<<a<<" "<<r<<endl; // 因为a和r的值会同时变化，所以a和r的值都是6。

r=10;

cout<<a<<" "<<r<<endl; // r变了，a也会变，所以a和r的值都是10。

return 0;

}

程序的执行结果是：

6 6

10 10

例1.9中展示了引用与变量的关系。r是a的引用，a变了，r的值也跟着变；r变了，a的值也跟着变。

2.?引用作为参数

引用一个重要的作用就是作为函数的参数。

【例1.10】　引用作为函数的参数举例。

#include<iostream>

using namespace std;

void Mmin1(int a,int b){

int temp;

if(a>b){

temp=a;

a=b;

b=temp;

}

void Mmin2(int &a,int &b){ // 引用作为函数的参数

int temp;

if(a>b){

temp=a;

a=b;

b=temp;

}

int main(){

int a=30,b=20;

Mmin1(a,b); //

cout<<a<<" "<<b<<endl; // a、b的值保持不变。

Mmin2(a,b);

cout<<a<<" "<<b<<endl; // a的值是20，b的值是30. a、b的值被修改了

return 0;

}

程序的执行结果是：

30 20

20 30

例1.10中定义了两个求最小值的函数，其中Mmin1是将一般变量作为函数的参数，Mmin2则是将引用作为函数的参数。

将一般变量作为函数的参数，传给形参的是变量的值，传递是单向的。如果在执行函数期间形参的值发生变化，并不传回给实参。因为在调用函数时，形参和实参不是同一个存储单元。

使用引用传递函数的参数时，在内存中并没有产生实参的副本，而是对实参直接操作。当使用一般变量传递函数的参数时，当函数发生调用，需要给形参分配存储单元，形参变量是实参变量的副本；如果传递的是对象，还将调用拷贝构造函数。因此，当参数传递的数据较大时，用引用比用一般变量传递参数的效率更高，所占空间更少。

使用指针作为函数的参数虽然也能达到与使用引用同样的效果，但是在被调函数中同样要给形参分配存储单元，且需要重复使用“*指针变量名”的形式进行运算，这很容易产生错误且程序的阅读性较差；另一方面，在主调函数的调用点处，必须用变量的地址作为实参，这些都不太方便。

综上所述，引用是个有效率的选择。

3.?常引用

如果既要提高程序的效率，又要使传递给函数的数据不在函数中被改变，就应该使用常引用。常引用的声明方式是：

const 类型标识符 &引用名=目标变量名;

用这种方式声明的引用，不能通过引用对目标变量的值进行修改，在程序中使引用的目标成为const类型，从而保证了引用的安全性，如下所示：

int a;

const int &r=a;

r=1; // 错误

a=1; // 正确

假设有如下函数声明：

string func1();

void func2(string &s);

那么下面的表达式都是非法的：

func2(func1);

func2("hello");

原因在于func1()和"hello"都将产生一个临时对象，而在C++中，这些临时对象都是const类型的。因此，上面的表达式就是试图将一个const类型的对象转化为非const类型，这是非法的。

引用型参数应该在能被定义成const的情况下，尽量定义为const。

1.6　结构体、公用体、枚举

1.6.1　结构体、共用体、枚举的概念

1.?结构体的声明方法

结构体的声明方法如下所示：

struct 结构名{

数据类型成员名;

...

};

成员表由若干成员组成，每个成员都是该结构的一个组成部分，对每个成员也必须做类型声明。例1.11说明了结构体的使用方法。

【例1.11】　结构体使用范例。

#include<iostream>

#include<string.h>

using namespace std;

struct student{ // 声明一个结构体类型student

int num;

char name[20];

int age;

}; // 最后有一个分号

int main(){

struct student stu1; // 定义一个student类型的变量stu1

student stu2; // 定义时也可以不用struct

stu1.num=1; // 单独对st1的num元素赋值

char temp[20]="Xiao ming";

strncpy(stu1.name,temp,strlen(temp));

stu1.age=10;

cout<<stu1.num<<" "<<stu1.name<<" "<<stu1.age<<endl;

student *stu3=&stu1; // stu3是结构体的指针，指向stu1

(*stu3).num=2; // stu1的num值被修改成了2;

cout<<stu1.num<<" "<<stu1.name<<" "<<stu1.age<<endl;

return 0;

}

程序的执行结果是：

1 Xiao ming 10

2 Xiao ming 10

例1.11中声明了一个结构体类型student，定义了两个student类型的变量stu1和stu2，分别用了两种定义方法，分别是前面有struct关键字和没有struct关键字。这两种定义方法都是可以的，显然没struct关键字的使用更为方便。

引用结构体变量中成员的一般方式为：

结构体变量名.成员名

例1.11中，stu1.num表示结构体变量stu1中的成员数量的值。

指针也可以应用于结构体，例1.11中stu3就是一个结构体变量，指向stu1。

2.?共用体

共用体，用关键字union来定义，它是一种特殊的类。在一个共用体里可以定义多种不同的数据类型，这些数据共享一段内存，在不同的时间里保存不同的数据类型和长度的变量，以达到节省空间的目的。但同一时间只能储存其中一个成员变量的值。

共用体的声明方式为：

union 共用体类型名{

数据类型成员名;

...

}变量名;

可以使用union判断系统是big endian（大端）还是little endian（小端）。

【例1.12】　判断系统是big endian还是little endian。

#include<iostream>

using namespace std;

union TEST{

short a;

char b[sizeof(short)];

};

int main(){

TEST test;

test.a=0x0102;// 不能引用共用体变量，只能引用共用体变量中的成员。

if(test.b[0]==0x01&&test.b[1]==0x02){

cout<<"big endian."<<endl;

}

else if(test.b[0]==0x02&&test.b[1]==0x01){

cout<<"small endian."<<endl;

}

else{

cout<<"unknown"<<endl;

}

return 0;

}

程序的执行结果是：

small endian.

其中，big endian是指低地址存放最高有效字节，little endian则是低地址存放最低有效字节。如果将0x1234abcd写入0x0000开始的内存中，则结果如表1-2所示。

表1-2　big endian和little endian的内存地址增长方向

地址 big endian little endian

0x0000 0x12 0xcd

0x0001 0x34 0xab

0x0002 0xab 0x34

0x0003 0xcd 0x12

表1-2展示了0x1234abcd分别在big endian的系统和在little endian的系统上的内存地址是怎么样分布的。例如0x0000是1Byte的存储单元，0x12单元一共占了8bit，也就是1byte，即占用了1Byte。

目前，几乎所有网络协议都是采用big endian的方式来传输数据的，当两台采用不同字节序的主机通信时，在发送数据之前都必须经过字节序的转换成为网络字节序（big endian）后再进行传播。

3.?枚举

在实际问题中，有些变量的取值被限定在一个有限的范围内。例如，一个星期只有7天，一年只有12个月，一个班每周有6门课程等。如果把这些量说明为整型，字符型或其他类型显然是不妥当的。为此，C语言提供了一种称为“枚举”的类型，枚举类型在C++中也同样适用。在“枚举”类型的定义中列举出所有可能的取值，用来说明该“枚举”类型的变量取值不能超过定义的范围。应该说明的是，枚举类型是一种基本数据类型，而不是一种构造类型，因为它不能再分解为任何其他基本类型。

枚举的声明方式为：

enum 枚举类型名{枚举常量表列};

如同结构和共用体一样，枚举变量也可用不同的方式说明，即先定义后说明，同时定义说明或直接说明。

设有变量a, b, c是枚举类型weekday，可采用下述任一种方式：

enum weekday{ sun,mou,tue,wed,thu,fri,sat };

enum weekday a,b,c;

或者为：

enum weekday{ sun,mou,tue,wed,thu,fri,sat }a,b,c;

或者为：

enum { sun,mou,tue,wed,thu,fri,sat }a,b,c;

枚举值是常量，不是变量。不能在程序中用赋值语句再对它赋值。

例如对枚举weekday的元素再作以下赋值，都是错误的：

sun=5;

mon=2;

sun=mon;

只能把枚举值赋予枚举变量，不能把元素的数值直接赋予枚举变量，如下面的语句是正确的：

a=sum;

b=mon;

而下面的语句则是错误的：

a=0;

b=1;

如一定要把数值赋予枚举变量，则必须用强制类型转换，如：

a=(enum weekday)2;

其意义是将顺序号为2的枚举元素赋予枚举变量a，相当于：

a=tue;

还应该说明的是枚举元素不是字符常量也不是字符串常量，使用时不要加单、双引号。

【例1.13】　enum使用范例。

#include<iostream>

using namespace std;

int main(){

enum weather{sunny,cloudy,rainy,windy};

/*其中sunny=0,cloudy=1,rainy=2,windy=3,

默认地，第一个枚举子被赋值为0*/

enum fruits{apple=3,orange,banana=7,bear};

/*也可以显式地赋值，接下来的枚举子取值是前面一个枚举子的取值+1，即orange=4，bear=8*/

cout<<orange<<endl;

enum big_cities{guangzhou=1,shenzhen=3, eijing=1,shanghai=2};

/*同一枚举中的枚举子的取值不需要是唯一的*/

return 0;

}

程序的执行结果是：

例1.13中定义了3个枚举类型：weather、fruits和big_cities，其中weather中的枚举子都被显式地赋值了，fruits中的枚举子只赋值了其中几个，没显式赋值的则是前面一个枚举子的取值+1。同一枚举类型中的枚举子的取值不需要是唯一的，可以相同。

1.6.2　结构体、共用体在内存单元占用字节数的计算

一般64位机器上各个数据类型所占的存储空间如下所述。

（1）char：8bit=1byte。

（2）short：16bit=2byte。

（3）int：32bit=4byte。

（4）long：64bit=8byte。

（5）float：32bit=4byte。

（6）double：64bit=8byte。

（7）long long：64bit=8byte。

其中，long类型在32位机器上只占4Byte，其他类型在32位机器和64位机器都是占同样的大小空间。先来看union占用内存单元字节数的计算方法。

【例1.14】　union的字节数计算。

#include<iostream>

using namespace std;

union A{

int a[5];

char b;

double c;

};

int main(){

cout<<sizeof(A)<<endl;

return 0;

}

程序的执行结果是：

union中变量共用内存，应以最长的为准，可是例1.14的执行结果却不是预想的20（int a[5],5*4 =20Byte），这是因为在共用体内变量的默认内存对齐方式，必须以最长的double（8Byte）对齐，也就是说应该是sizeof(A)=24。所以将共用体中的int a[5]修改成int a[6]后，结果仍然不变；但如果将int a[5]修改成int a[7]，结果就将变成32。

再来看struct的计算方法。

【例1.15】　struct的字节数计算。

#include<iostream>

using namespace std;

struct B{

char a;

double b;

int c;

}test_struct_b;

int main(){

cout<<sizeof(test_struct_b)<<endl;

return 0;

}

程序的执行结果是：

这是因为char a的偏移量为0，占用1Byte；double b指的是下一个可用的地址的偏移量为1，不是sizeof(double)=8，需要补足7Byte才能使偏移量变为8；int c指的是下一个可用的地址的偏移量为16，是sizeof(int)=4的倍数，满足int的对齐方式。

故所有成员变量都分配了空间，空间总的大小为1+7+8+4=20，不是结构的节边界数（即结构中占用最大空间的类型所占用的字节数sizeof (double)=8）的倍数，所以需要填充4Byte，以满足结构的大小为sizeof(double)=8的倍数，即24。

再来看一个混合结构体的大小计算。

【例1.16】　一个混合结构体大小的计算。

#include<iostream>

using namespace std;

typedef union{

long i;

int k[5];

char c;

} UDATE;

struct data{

int cat;

UDATE cow;

double dog;

}too;

UDATE temp;

int main(){

cout<<sizeof(struct data)+sizeof(temp)<<endl;

return 0;

}

假设是测试机器是在64位机器上，那么程序的执行结果应该是多少？UDATE是一个union，作为变量公用空间。里面占用字节数最多的变量是int k[5]，有20Byte，但它要与long类型的8Byte对齐，所以占用24Byte。所以sizeof(struct data)是24，temp是一个struct，每个变量分开占用空间.依次为int4+UDATE28+double8=40，40是4和8的公倍数，字节已对齐，故sizeof(temp)是40，所以结果是40+24=64。

1.7　预处理

C++提供的预处理功能主要有以下4种：宏定义、文件包含、条件编译和布局控制。文件包含在前面已描述过，下面重点描述宏定义、条件编译和布局控制，其中又着重讲述常用宏定义命令、do…while(0)的妙用、条件编译及extern"C"块的应用知识。

1.?常用宏定义命令

#def?ine命令是一个宏定义命令，它用来将一个标识符定义为一个字符串，该标识符被称为宏名，被定义的字符串称为替换文本。该命令有两种格式：一种是简单的宏定义，另一种是带参数的宏定义。

简单的宏定义的声明格式如下所示：

#define 宏名字符串

例：#def?ine PI 3.1415926

带参数的宏定义的声明格式如下所示：

#define 宏 (参数表列) 宏

例：#def?ine A(x) x

使用宏定义中，要注意以下问题。

（1）在简单宏定义的使用中，当替换文本所表示的字符串是一个表达式时，需要加上括号，否则容易引起误解和误用。

【例1.17】　简单宏定义不加括号容易引起误用。

#include<iostream>

#define N 2+9

using namespace std;

int main(){

int a=N*N;

cout<<a<<endl;

return 0;

}

程序的执行结果是：

例1.17中就出现了问题：在此程序中存在着宏定义命令，宏N代表的字符串是2+9，在程序中有对宏N的使用，一般同学在读该程序时，容易产生的问题是先求解N为2+9=11，然后在程序中计算a时使用乘法，即N*N=11*11=121，其实该题的结果为29，为什么结果有这么大的偏差?因为宏展开是在预处理阶段完成的，这个阶段把替换文本只是看作一个字符串，并不会有任何的计算发生，在展开时是在宏N出现的地方只是简单地使用串2+9来代替N，并不会增添任何的符号，所以对该程序展开后的结果是a=2+9*2+9，计算后结果为29。要程序如之前想要的结果，只需要写成#def?ine N (2+9)，即加上括号就行。

（2）类似地，在带参数的宏定义的使用中，也容易引起误解。例如当需要使用宏替换来求任何数的平方，这时就需要使用参数，以便在程序中用实际参数来替换宏定义中的参数。初学者容易写成如例1.18中的形式。

【例1.18】　带参数的宏定义不加括号容易引起误用。

#include<iostream>

using namespace std;

#define area(x) x*x

int main()

{

int y = area(2+2);

cout<<y<<endl;

return 0;

}

程序的执行结果是：

表面上看，给的参数是2+2，所得的结果应该为4*4=16，但该程序的实际结果为8。宏定义中要遵循先替换后计算的原则，在上面的程序里，2+2即为宏area中的参数，应该由它来替换宏定义中的x，即替换成2+2*2+2=8了。那如果遵循（1）中的解决办法，把2+2括起来，即把宏体中的x括起来，是否可以解决呢？#def?ine area(x) (x)*(x)，对于area(2+2)，替换为(2+2)*(2+2)=16，可以解决，但是对于area(2+2)/area(2+2)又会怎么样呢，有人一看到这道题马上给出结果1，因为分子分母一样，那么这样就又错了。遵循先替换再计算的规则，这道题替换后会变为(2+2)*(2+2)/(2+2)*(2+2)即4*4/4*4按照乘除运算规则，结果为16/4*4=4*4=16。解决这类问题的方法是在整个宏体上再加一个括号，即#def?ine area(x) ((x)*(x))，不要觉得这没必要，没有它是不行的。

要想能够真正使用好宏定义，在读别人的程序时，一定要记住先将程序中对宏的使用全部替换成它所代表的字符串，不要自作主张地添加任何其他符号，完全展开后再进行相应的计算，就不会求错运行结果。

如果是自己在编程时使用宏替换，则在使用简单宏定义时，当字符串中不只一个符号时，加上括号表现出优先级，如果是带参数的宏定义，则要给宏体中的每个参数加上括号，并在整个宏体上再加一个括号。

2.?do...while(0)的妙用

大家都知道，do{…}while(condition)可以表示循环，但你有没有遇到在一些宏定义中可以不用循环的地方，也用到了do{…}while，比如有这样的宏：

#define Foo(x) do{\

statement one;\

statement two;\

}while(0) // 这里没有分号

粗看会觉得很奇怪，既然循环里面只执行了一次，那要这个看似多余的do...while(0)有什么意义呢？再来看这样的宏：

#define Foo(x) {\

statement one;\

statement two;\

}

这两个看似一样的宏，其实是不一样的。前者定义的宏是一个非复合语句，而后者却是一个复合语句。假如有这样的使用场景：

if(conditon)

Foo(x);

else

...;

因为宏在预处理的时候会直接被展开，采用第2种写法，会变成：

if(condition)

statement one;

statement two;

else

...///

这样会导致else语句孤立而出现编译错误。加了do{...}while(0)，就使得宏展开后，仍然保留初始的语义，从而保证程序的正确性。

3.?条件编译

一般情况下，源程序中所有行的语句都参加编译。但是有时程序员希望其中一部分内容只在满足一定条件时才进行编译，也就是对一部分内容指定编译的条件，这就用到了“条件编译”。

条件编译命令最常见的形式为：

#ifdef 标识符

程序段1

#else

程序段2

#endif

它的作用是：当标识符已经被定义过（一般是用#def?ine命令定义），则对程序段1进行编译，否则编译程序段2。其中#else部分也可以没有，即：

#ifdef 标识符

程序段1

#endif

下面这样的形式则是当指定的表达式值为真（非零）时就编译程序段1，否则编译程序段2。可以事先给定一定条件，使程序在不同的条件下执行不同的功能。

#if 表达式

程序段1

#else

程序段2

#endif

这里的“程序段”可以是语句组，也可以是命令行。

有时候程序中的某些调试代码，只需要在调试的时候被编译，而不希望在程序的正式发行版中被编译，你可能会看到类似例1.19这样的代码段。

【例1.19】　调试代码巧用条件编译。

#include<iostream>

using namespace std;

#define _DEBUG_

int main(){

int x=10;

#ifdef _DEBUG_

cout<<"File:"<< __FILE__<<",Line:"<< __LINE__<<",x:"<<x<<endl;

#else

printf("x = %d\n", x);

cout<<x<<endl;

#endif

return 0;

}

程序的运行结果是：

File:test.cpp,Line:7,x:10

当_DEBUG_没有被定义的时候，仅编译#else与#endif之间的代码；当定义了_DEBUG_符号之后，则会编译#ifdef与#else之间的代码。要想定义一个符号很简单，只需要在文件头部加上像这样的一条语句：

#define _DEBUG_

用#def?ine命令的目的不在于用_DEBUG_代表一个字符串，而只是表示已定义过_DEBUG_，因此_DEBUG_后面写什么字符串都无所谓，甚至可以不写字符串。

4.?extern "C"块的应用

经常能在C与C++混编的程序中看到这样的语句：

#ifdef __cplusplus

extern "C" {

#endif

...

#ifdef __cplusplus

}

#endif

其中，__cplusplus是C++的预定义宏，表示当前开发环境是C++。在C++语言中，为了支持重载机制，在编译生成的汇编代码中，会对函数名字进行一些处理（通常称为函数名字改编），如加入函数的参数类型或返回类型等，而在C语言中，只是简单的函数名字而已，并不加入其他信息，如下所示：

int func(int demo);

int func(double demo);

C语言无法区分上面两个函数的不同，因为C编译器产生的函数名都是_func，而C++编译器产生的名字则可能是_func_Fi和_func_Fd，这样就很好地把函数区别开了。

所以，在C/C++混合编程的环境下，extern "C"块的作用就是告诉C++编译器这段代码要按C标准编译，以尽可能地保持C++与C的兼容性。例1.20说明了__cplusplus的使用方法。

【例1.20】　__cplusplus的使用方法。

#include<stdio.h>

int main() {

#define TO_LITERAL(text) TO_LITERAL_(text)

#define TO_LITERAL_(text) #text

#ifndef __cplusplus

/* this translation unit is being treated as a C one */

printf("a C program\n");

#else

/*this translation unit is being treated as a C++ one*/

printf("a C++ program\n__cplusplus expands to \""

TO_LITERAL(__cplusplus) "\"\n");

#endif

return 0;

}

程序的执行结果是：

a C++ program

__cplusplus expands to "1"

例1.20中程序的意思是：如果没有定义__cplusplus，那么当前源代码就会被当作C源代码处理；如果定义了__cplusplus，那么当前源代码会被当中C++源代码处理，并且输出__cplusplus宏被展开后的字符串。

1.8　本章小结

本章抛砖引玉地讲述了C++中的常用技术，通过简单的例子，读者可轻易学会其使用方法。读者在实际编程时，简单的知识点直接查阅本章即可。

学习C++，既要会利用C++进行面向过程的结构化程序设计，也要会利用C++进行面向对象的程序设计。接下来的第2章，我们将学习面向对象的C++。

第2章

面向对象的C++

学习C++，一定要学会面向对象编程。首先讲下“面向对象”产生的历史原因，主要有以下两点。

（1）计算机只会按照人所写的代码，一步一步地执行下去，最终得到结果。无论程序多么复杂，计算机总是能轻松应付。结构化编程，就是按照计算机的思维写出的代码，但是人看到这么复杂的逻辑，无法进行维护和扩展。

（2）结构化设计是以功能为目标来构造应用系统，这种做法导致程序员设计程序时，不得不将客体所构成的现实世界映射到由功能模块组成的解空间中，这种转换过程，背离了人们观察和解决问题的基本思路。

可见，结构化设计在构造系统的时候，无法解决重用、维护、扩展的问题，而且会导致逻辑过于复杂，代码晦涩难懂。于是人们就想，能不能让计算机直接模拟现实的环境，用人类解决问题的思路、习惯、步骤来设计相应的应用程序？这样的程序，人们在读它的时候，会更容易理解，也不需要再把现实世界和程序世界之间来回做转换。于是面向对象的编程思想就产生了。

本章主要从面向对象的封装、继承和多态三大特征来带读者进入面向对象的C++世界。

2.1　类与对象

1.?类与对象的概念

面向对象编程的主要思想是把构成问题的各个事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描述一个事物在解决问题中经过的步骤和行为。对象作为程序的基本单元，将程序和数据封装其中，以提高软件的重用性、灵活性和扩展性。类，是创建对象的模板，一个类可以创建多个相同的对象；对象，是类的实例，是按照类的规则创建的。类与对象的关系如图2-1所示。

图2-1中，人和学生属于类，张三和学生李四都是对象，姓名、身高、地址、年龄、性别、血型都是人这一类的属性，跑步、吃饭，这都是人这个类的方法。属性是一个变量，用来表示一个对象的特征；方法是一个函数，用来表示对象的操作。对象的属性和方法统称为对象的成员。

每一个实体都是对象，有一些对象是具有相同的结构和特性的。每个对象都属于一个特定的类型，这个特定的类型称为类。正如结构体类型和结构体变量一样，需要先声明一个结构体类型，再用它去定义结构体变量。在C++中也是先声明一个类的类型，然后用它去定义若干个同类型的对象。可以说，对象是类类型的一个变量，类则是对象的模板。类是抽象的，不占用存储空间的；而对象是具体的，占用存储空间。

类类型的声明形式如下：

class类名{ // class,声明一个类必须有的关键字

private:

私有的数据和成员函数;

public:

公用的数据和成员函数;

}; // 类的声明以分号结束

其中，private和public称为成员访问限定符。

下面再来看下结构体和类的不同之处。例2.1展示了在C++中声明一个结构体类型的方法；例2.2则是声明一个类的方法。

【例2.1】　声明一个结构体类型。

struct SStudent{

int num;

char name[20];

int age;

};

SStudent st_stu1,st_stu2; // 定义了两个结构体变量

【例2.2】　声明一个类。

class CStudent{

int num;

char name[20];

int age; // 这些是数据成员，也称为成员变量

void display(){ // 这是成员函数

cout<<"num:"<<num<<endl;

cout<<"name:"<<name<<endl;

cout<<"age:"<<age<<endl;

}

};

CStudent cstu1,cstu2; // 定义了两个对象

例2.1中声明了一个SStudent结构体，结构体内有三个数据成员：num、name[20]和age；还定义了两个SStudent结构体类型的变量st_stu1和st_stu1。例2.2中声明了一个CStudent类，类中有三个数据成员和一个成员函数display，还定义了两个对象cstu1和cstu2。

从上面结构体的声明方法和类的声明方法来看，貌似只有关键字不一样，结构体的关键字是struct，类的关键字是class。事实上，声明类的方法是由声明结构体类型的方法发展而来的。但是，struct中的成员访问权限默认是public，而class中则默认是private的。在C语言里，struct中不能定义成员函数，而在C++中，增加了class类型后，扩展了struct的功能，struct中也能定义成员函数了。

【例2.3】　struct中定义成员函数。

struct SStudent{

public:

void display(){ // 这是成员函数

cout<<"num:"<<num<<endl;

cout<<"name:"<<name<<endl;

cout<<"age:"<<age<<endl;

} // 这里没有分号

private:

int num;

char name[20];

int age;

};

例2.3中在结构体SStudent中定义了一个display的public的成员函数，3个private的成员变量。请注意，一个成员函数如果在类中定义，在定义结束的｝之后是不需要加分号的。

在一个类中，关键字private和public可以分别出现多次，从每个部分的有效范围到出现另一个访问限定符或者类体结束为止。为了使程序清晰，建议大家养成良好的习惯，使每一种成员访问限定符在类体中只出现一次，并且先写public部分，把private部分放在类体的后部，这样可以使得用户将注意力集中在能被外界调用的成员上，使得阅读者的思路更加清晰。

一个对象的声明方式有以下几种。

（1）class　类名　对象名。

（2）类名　对象名。

这两种方法是等效的，但显然第二种方法更为简洁与方便。

2.?成员函数

类的成员函数是函数的一种，与第1章介绍过的函数一样，具有返回值和函数类型，它与一般函数的区别在于，它是属于类的成员，出现在类体中。它可以被指定为private（私有的）、protected（受保护的）和public（公用的）。

在使用成员函数时，要注意它的权限以及作用域。比如，私有的成员函数只能被本类中其他成员函数使用，而不能在类外被调用。成员函数中可以使用类中的任何成员，包括私有的和公用的。

成员函数可以在类体中定义，也可以在类外定义。

【例2.4】　成员函数在类外被定义。

class CStudent {

public:

void display(); // 这里需要分号

private:

int num;

char name[20];

int age;

};

void CStudent::display(){

cout<<"num:"<<num<<endl;

cout<<"name:"<<name<<endl;

cout<<"age:"<<age<<endl;

}

例2.4中在类CStudent外定义了display成员函数。注意，在类外定义成员函数时，必须加上类名，予以限定。“::”是作用域限定符或作用域运算符，用它声明函数是属于哪个类的。如果没有写类名或者没有写类名和作用域限定符，则这个函数不属于任何类，而是一个普通函数。成员函数必须先在类中声明，然后再在类外定义，即类体的位置应在函数定义之前，否则编译时会出错。

3.?类的封装性

C++中通过类实现封装性，把数据和这些数据有关的操作封装在一个类里。但是，人们在使用时，往往不关心类中的具体实现，而只需知道调用哪个函数会得到什么结果，能实现什么功能即可。

为了实现类对象的封装性（数据隐藏和提供访问接口），类类型定义为类成员提供了私有、公有和受保护的3种基本访问权限供用户选择，具体内容如下所述。

（1）私有成员

1）访问权限：只限于类成员访问。

2）关键字：private。

3）私有段：从private关键字开始至其他访问权限声明之间所有成员组成的代码段。

4）成员种类：数据成员和成员函数。

（2）公有成员

1）访问权限：允许类成员和类外的任何访问。

2）关键字：public。

3）私有段：从public关键词开始至其他访问权限声明之间所有成员组成的代码段。

4）成员种类：数据成员和成员函数。

（3）受保护成员

1）访问权限：允许类成员和派生类成员访问，不运行类外的任何访问。

2）关键字：protect。

3）私有段：从protect关键词开始至其他访问权限声明之间所有成员组成的代码段。

4）成员种类：数据成员和成员函数。

除了限制访问权限，在写代码时经常要注意“将接口与实现分离”，这也是隐蔽信息的一个重要手段。接口与实现分离，有以下两个好处：①如果想修改或者扩充类的功能，只需要修改类中的实现，类外部分可以不用修改；②如果发现类中数据成员数据有错，则只需要在类内检查访问这些数据成员的成员函数。

一般是将类的声明放在指定的头文件中，用户如果想使用这个类，直接包含这个头文件即可。因为在头文件中有类的声明，所以可以直接在程序中用这个类来定义对象。为了实现信息隐蔽，会把类成员函数的定义放在另一个文件中，而不放在头文件中。

例如，可以将类Student的声明放在student.h中。

【例2.5】　类的定义与使用。

student.h中的代码为：

class CStudent{

public:

void display();

private:

int num;

char name[20];

int age;

};

student.cpp中的代码为：

#include<iostream>

#include "student.h" // 这里需要include这个头文件，否则无法找到Student类

using namespace std;

void CStudent::display(){ // 这里要注明是Student类的

cout<<"num:"<<num<<endl;

cout<<"name:"<<name<<endl;

cout<<"age:"<<age<<endl;

}

main.cpp中的代码为：

#include<iostream>

#include "student.h" // 注意这里是双引号

int main(){

CStudent stu1; // 定义stu1对象

stu1.display(); // 指向stu1对象的成员函数

return 0;

}

执行以下这3行命令即可编译成功：

g++ -c student.cpp

g++ -c main.cpp

g++ -o main main.o student.o

编译后，会生成main文件，执行./main命令，获得程序的执行结果为：

num:0

name:

age:0

这种结果是由于还没有对数据成员进行初始化导致的，下面的一节会介绍如何初始化一个对象。

例2.5中定义了一个类CStudent，所有的数据成员和成员函数都声明在头文件student.h中，而成员函数的定义则是在.cpp文件student.cpp中。main.cpp中要使用CStudent类时需要把头文件student.h包含进来。编译时，编译器g++会把main.cpp和student.cpp分别编译成main.o和student.o，再把main.o和student.o链接成可执行文件main，图2-2展示了这一过程。

编译与链接的相关知识会在第4章详细展开，这里只作简单介绍。

4.?构造函数

数据成员是不能在类中初始化的，而构造函数，正是为此而生，主要用来处理数据成员的初始化。它不需要用户调用，而是在建立对象时自动执行的。

构造函数的名字必须与类名相同，而不能由用户任意命名，以便编译系统能识别它并把它作为构造函数处理。它是一个没有返回值的函数，构造函数在类中定义如例2.6所示。

【例2.6】　构造函数的定义。

class Time{

public:

Time(){ // 这就是构造函数

hour=0;

minute=0;

second=0;

}

set_time();

get_time();

private:

int hour,minute,second;

};

构造函数也可以在类外定义，如例2.7所示。

【例2.7】　在类外定义构造函数。

class Time{

public:

Time(); // 对构造函数进行声明

set_time();

get_time();

private:

int hour,minute,second;

};

Time::Time(){ // 定义构造函数，需要加上类名和域限定符"::"

hour=0;

minute=0;

second=0;

}

在构造函数的函数体中，不仅可以对数据成员赋值，也可以包含其他语句。不过不提倡在构造函数中加入与初始化无关的内容，以保证程序清晰。如果用户自己没有定义构造函数，那么C++系统就会自动为其生成一个构造函数，只是这个构造函数的函数体是空的，什么也不做，当然也不进行初始化。

构造函数分为不带参数的构造函数与带参数的构造函数。不带参数的构造函数使该类的每一个对象都得到相同的初始值；带参数的构造函数则可以方便地实现对不同的对象进行不同的初始化。

【例2.8】　带参数的构造函数的使用举例。

#include<iostream>

using namespace std;

#define pi 3.1415

class Circle{

public:

Circle(int r); // 形参列表

double Area();

private:

int radius; // 数据成员

};

Circle::Circle(int r){

radius=r;

}

double Circle::Area(){

return pi*radius*radius;

}

int main(){

Circle cir1(10);

cout<<"cir1's area: "<<cir1.Area()<<endl;

Circle cir2(1);

cout<<"cir2's area: "<<cir2.Area()<<endl;

return 0;

}

程序的执行结果是：

cir1's area: 314.15

cir2's area: 3.1415

例2.8中的构造函数带了一个整型的参数，并在构造函数中将r参数赋值给了成员变量radius。定义对象时可利用构造函数直接对成员变量赋值。

另外，C++还提供另一种初始化数据成员的方法：参数初始化表。这种方法不在函数体内对数据成员初始化，而是在函数首部实现。例2.8中的构造函数可以改写为下列形式：

Circle::Circle(int r):radius(r){} // 后面没有分号

在C++中，一个类可以同时定义多个构造函数，以提供不同的初始化方法。这些构造函数的参数个数不同或参数的类型不同，这就是构造函数的重载。

【例2.9】　构造函数重载的使用。

#include <iostream>

using namespace std;

class Box{

public:

Box(); // 声明一个无参的构造函数

/*声明一个有参的构造函数，并用参数的初始化列表对数据成员初始化*/

Box(int h,int w,int l):height(h),width(w),length(l){}

int volume();

private:

int height,width,length;

};

Box::Box(){ // 定义无参的构造函数

height=1;

width=2;

length=3;

}

int Box::volume(){

return height*width*length;

}

int main(){

Box box1; // 不指定实参

cout<<"box1's volume: "<<box1.volume()<<endl;

Box box2(2,5,10); // 指定实参

cout<<"box2's volume: "<<box2.volume()<<endl;

return 0;

}

程序的执行结果是：

box1's Volume: 6

box2's Volume: 100

例2.9中定义了两个构造函数，一个是无参的，一个是有参的，两个函数的函数名一样，但参数格式不一样，所以是函数重载。若定义对象时不指定实参，则调用无参的构造函数。

调用构造函数时不必给出实参的构造函数，称为默认构造函数。无参的构造函数属于默认构造函数。一个类只能有一个默认构造函数。即使一个类中有多个构造函数，但建立对象时，都只执行其中一个构造函数。

构造函数中的参数的值，可以通过实参传递，也可以指定为某些默认值。

【例2.10】　构造函数默认参数的使用。

#include <iostream>

using namespace std;

class Box{

public:

Box(int h=2,int w=2,int l=2); // 在声明构造函数时指定默认参数

int volume();

private:

int height,width,length;

};

Box::Box(int h,int w,int len){ // 在定义函数时可以不指定默认参数

height=h;

width=w;

length=len;

}

int Box::volume(){

return height*width*length;

}

int main(){

Box box1(1); // 不指定第2、3个实参

cout<<"box1's volume: "<<box1.volume()<<endl;

Box box2(1,3); // 不指定第3个实参

cout<<"box2's volume: "<<box2.volume()<<endl;

return 0;

}

程序的执行结果是：

box1's volume:4

box2's volume:6

例2.10中定义了一个带有默认参数的构造函数，是在声明时指定默认参数，而定义时则可以不指定默认参数。定义对象时，可以传0～3个参数，传了几个参数，就替换前面的几个参数，其余都还是使用默认参数。

使用默认参数的好处在于：调用构造函数时就算没有提供参数也不会出错，且对每一个对象能有相同的初始化状况。

不过，应该在声明构造函数默认值时指定默认参数值，而不能只在定义构造函数时指定默认参数值。如果构造函数中的参数全指定了默认值，则在定义对象时，可给一个实参或多个实参，也可以不给实参。

一个类中如果定义了全是默认参数的构造函数后，就不能再定义重载构造函数了。假设Box类定义了以下3个构造函数：

Box(int =10,int =10,int =10);

Box();

Box(int,int);

若有以下定义语句，思考注释中的问题：

Box box1; // 是调用上面的第一个默认参数的构造函数，还是第二个默认构造函数？

Box box2(15,30); // 是调用上面的第一个默认参数的构造函数，还是第三个构造函数？

5.?析构函数

析构函数的名字是类名的前面加一个“~”符号。在C++中，“~”符号是位取反运算符，类似地，析构函数的作用与构造函数相反。它也不需要用户来调用它，不过，它是在对象声明周期结束时自动执行的。

程序执行析构函数的时机有以下4种。

（1）如果在函数中定义了一个对象，当这个函数调用结束时，对象会被释放，且在对象释放前会自动执行析构函数。

（2）static局部对象在函数调用结束时对象不释放，所以也不执行析构函数，只有在main函数结束或调用exit函数结束程序时，才调用static局部对象的析构函数。

（3）全局对象则是在程序流程离开其作用域（如main函数结束或调用exit函数）时，才会执行该全局对象的析构函数。

（4）用new建立的对象，用delete释放该对象时，会调用该对象的析构函数。

析构函数的作用不是删除对象，而是在撤销对象占用的内存前完成一些清理工作，使得这些内存可以供新对象使用。析构函数的作用也不限于释放资源方面，它还可以被用来执行用户希望在最后一次使用对象之后所执行的任何操作。

【例2.11】　析构函数的使用方法举例。

#include<iostream>

using namespace std;

class Box{

public:

Box(int h=2,int w=2,int l=2);

~Box(){ // 析构函数

cout<<"Destructor called."<<endl; // 析构函数里的内容

}

int volume(){

return height*width*length;

}

private:

int height,width,length;

};

Box::Box(int h,int w,int len){

height=h;

width=w;

length=len;

}

int main(){

Box box1;

cout<<"The volume of box1 is "<<box1.volume()<<endl;

cout<<"hello."<<endl;

return 0;

}

程序的运行结果：

The volume of box1 is 8

hello.

Destructor called.

例2.11中定义了类Box的析构函数，析构函数中输出Destructor called.，也就是析构函数被执行时就会输出这条消息。由程序的执行结果可以看出，析构函数是对象释放内存前执行的。

如果用户没有编写析构函数，编译系统会自动生成一个默认的析构函数，但不进行任何操作，所以许多简单的类中没有用显式的析构函数。

6.?静态数据成员

有时需要为某个类的所有对象分配一个单一的存储空间。在C语言中，可以使用全局变量，但这样很不安全。全局数据可以被任何人修改，而且在一个项目中，它很容易和其他名字冲突。如果可以把数据当成全局变量那样去存储，但又被隐藏在类的内部，而且清楚地与这个类相联系，这种处理方法就是最理想的。这个可以用类的静态数据成员来实现。类的静态成员拥有一块单独的存储区，而不管创建了多少个该类的对象。所有这些对象的静态数据成员都共享这一块静态存储空间，这就为这些对象提供了一种互相通信的方法。静态数据成员是属于类的，它只在类的范围内有效，可以是public、private或protected的范围。

因为不管产生了多少对象，类的静态数据成员都有着单一的存储空间，所以存储空间必须定义在一个单一的地方。如果一个静态数据成员被声明而没有被定义，链接器会报告一个错误：“定义必须出现在类的外部而且只能定义一次”。因此静态数据成员的声明通常会放在一个类的实现文件中。举例如下所示。

xxx.h类型文件中：

class base{

public:

static int var; // 声明静态数据成员

};

xxx.cpp类型文件中：

int base::var=10; // 定义静态数据成员,不必在初始化语句里加上static

在头文件中定义（初始化）静态成员容易引起重复定义的错误，比如这个头文件同时被多个.cpp文件所包含的时候。即使加上#ifndef #def?ine #endif或者#pragma once也不行。

C++静态数据成员被类的所有对象所共享，包括该类的派生类的对象。派生类对象与基类对象共享基类的静态数据成员。静态的数据成员在内存中只占一份空间。如果改变它的值，则在各个对象中这个数据成员的值同时都改变了，这样可以节约空间，提高效率。下面程序展示了修改基类的静态数据成员，同时影响派生类对象和基类对象的情况。

【例2.12】　静态的数据成员基类和派生类对象共享。

#include<iostream>

using namespace std;

class Base{

public:

static int var;

};

int Base::var=10;

class Derived:public Base{

};

int main(){

Base base1;

base1.var++; // 通过对象名引用

cout<<base1.var<<endl; // 输出11

Base base2;

base2.var++;

cout<<base2.var<<endl; // 输出12

Derived derived1;

derived1.var++;

cout<<derived1.var<<endl; // 输出13

Base::var++; // 通过类名引用

cout<<derived1.var<<endl; // 输出14

return 0;

}

程序的执行结果是：

例2.12中在基类Base中定义了一个静态数据成员var，类Derived继承了类Base。无论是通过基类对象，或者是派生类对象，都可以改变静态数据成员var的值。

如果只声明了类而未定义对象，类的一般数据成员是不占内存空间的，只有在定义对象时才会为对象的数据成员分配空间。但是静态数据成员不属于某一个对象，所以在为对象所分配的空间中不包括静态数据成员所占的空间，静态数据成员是在所有对象之外单独开辟一段空间来存放。只要在类中定义了静态数据成员，即使不定义对象，也为静态数据成员分配了空间，它可以被引用。

在一个类中可以有一个或多个静态数据成员，所有对象都共享这些静态数据成员，都可以引用它。

如果在一个函数中定义了静态变量，在函数结束时该静态变量并不被释放，仍然存在并保留其值。静态数据成员也类似，它不随对象的建立而分配空间，也不随对象的撤销而释放。静态数据成员是程序在编译时被分配空间，到程序结束时释放空间。

静态数据成员可以通过对象名引用，也可以通过类名来引用。

7.?静态成员函数

与数据成员类似，成员函数也可以定义为静态的，在类中声明函数的前面加static关键字就成了静态成员函数，如：

static int volume();

和静态数据成员一样，静态成员函数也是类的一部分，而不是对象的一部分。如果要在类外调用公用的静态成员函数，要用类名和域运算符“::”，如：

Box::volume( );

实际上也允许通过对象名调用静态成员函数，如：

a.volume( );

但这并不意味着此函数是属于对象a的，而只是用a的类型而已。

与静态数据成员不同，静态成员函数的作用不是为了对象之间的沟通，而是为了能处理静态数据成员。

当调用一个对象的成员函数（非静态成员函数）时，系统会把该对象的起始地址赋给成员函数的this指针。而静态成员函数并不属于某一对象，它与任何对象都无关，因此静态成员函数没有this指针。既然它没有指向某一对象，也就无法对一个对象中的非静态成员进行默认访问（即在引用数据成员时不指定对象名）。

可以说，静态成员函数与非静态成员函数的根本区别是：非静态成员函数有this指针，而静态成员函数没有this指针。由此决定了静态成员函数不能访问本类中的非静态成员。

静态成员函数可以直接引用本类中的静态数据成员，因为静态成员同样是属于类的，可以直接引用。在C++程序中，静态成员函数主要用来访问静态数据成员，而不访问非静态成员。

假如在一个静态成员函数中有以下语句：

cout<<height<<endl; // 若height已声明为static,则引用本类中的静态成员，合法

cout<<width<<endl; // 若width是非静态数据成员，不合法

但是，并不是绝对不能引用本类中的非静态成员，只是不能进行默认访问，因为无法知道应该去找哪个对象。如果一定要引用本类的非静态成员，应该加对象名和成员运算符“.”，如：

cout<<a.width<<endl; // 引用本类对象a中的非静态成员

假设a已定义为Box类对象，且在当前作用域内有效，则此语句合法。不过，最好养成这样的习惯：只用静态成员函数引用静态数据成员，而不引用非静态数据成员。这样思路更清晰、逻辑更清楚，不易出错。

【例2.13】　静态成员函数的使用方法举例。

#include<iostream>

using namespace std;

class CStudent{

public:

CStudent (int n,int s):num(n),score(s){} // 定义构造函数

void total();

static double average();

private:

int num;

int score;

static int count;

static int sum; // 这两个数据成员是所有对象共享的

};

int CStudent::count=0; // 定义静态数据成员

int CStudent::sum=0;

void CStudent::total(){ // 定义非静态成员函数

sum+=score; // 非静态数据成员函数中可使用静态数据成

// 员、非静态数据成员

count++;

}

double CStudent::average(){ // 定义静态成员函数

return sum*1.0/count; // 可以直接引用静态数据成员，不用加类名

}

int main(){

CStudent stu1(1,100);

stu1.total(); // 调用对象的非静态成员函数

CStudent stu2(2,98);

stu2.total();

CStudent stu3(3,99);

stu3.total();

cout<< CStudent::average()<<endl; // 调用类的静态成员函数，输出99

}

程序的执行结果是：

例2.13中声明了一个CStudent类，类中有静态成员函数average、静态数据成员count和sum。静态数据成员count和sum必须在类的外部定义，在非静态成员函数total中可以使用静态数据成员、非静态数据成员，而在静态成员函数中则可以不加类名直接引用静态数据成员。

8.?对象的存储空间

很多C++书籍中都介绍过一个对象需要占用多大的内存空间，最权威的结论是：非静态成员变量总和加上编译器为了CPU计算做出的数据对齐处理和支持虚函数所产生的负担的总和。下面分别看看数据成员、成员函数、构造函数、析构函数、虚函数的空间占用情况。

先来看看一个空类的存储空间是多少个Byte呢？可以看例2.14的程序。

【例2.14】　空类存储空间的计算。

#include<iostream>

using namespace std;

class CBox{

};

int main(){

CBox boxobj;

cout<<sizeof(boxobj)<<endl;// 输出1

return 0;

}

程序的执行结果是：

例2.14中定义了一个空类CBox，里面既没有数据成员，也没有成员函数。程序执行结果显示它的大小为1。

空类型对象中不包含任何信息，应该大小为0。但是当声明该类型的对象的时候，它必须在内存中占有一定的空间，否则无法使用这些对象。至于占用多少内存，由编译器决定。C++中每个空类型的实例占1Byte空间。

【例2.15】　只有成员变量的类的存储空间计算。

#include<iostream>

using namespace std;

class CBox{

int length,width,height;

};

int main(){

CBox boxobj;

cout<<sizeof(boxobj)<<endl;

return 0;

}

程序的执行结果是：

例2.15中，类CBox中只有3个成员变量，由于整型变量占4Byte，所以对象所占的空间就是12Byte。那静态成员变量是否也占存储空间呢？

【例2.16】　有成员变量和静态成员变量的类的存储空间计算。

#include<iostream>

using namespace std;

class CBox{

int length,width,height;

static int count;

};

int main(){

CBox boxobj;

cout<<sizeof(boxobj)<<endl;

return 0;

}

程序的执行结果是：

例2.16中，类CBox中有3个普通数据成员和1个静态数据成员，比例2.14中多了一个静态数据成员，但是程序的执行结果还是12，也就证明了静态数据成员是不占对象的内存空间的。

【例2.17】　类中只有1个成员函数的存储空间计算。

#include<iostream>

using namespace std;

class CBox{

int foo();

};

int main(){

CBox boxobj;

cout<<sizeof(boxobj)<<endl;

return 0;

}

程序的执行结果是：

例2.17中类CBox中只有一个成员函数，类CBox的对象boxobj的大小却只有1Byte，和空类对象是一样的，所以可以得出，成员函数是不占空间的。

【例2.18】　类中构造函数、析构函数的空间占用情况。

#include<iostream>

using namespace std;

class CBox{

public:

CBox(){};

~CBox(){};

};

int main(){

CBox boxobj;

cout<<sizeof(boxobj)<<endl;

return 0;

}

程序的执行结果是：

例2.18中类CBox中只有构造函数和析构函数，类CBox的对象boxobj的大小也只有1Byte，和空类对象是一样的，所以可以得出，构造函数和析构函数也是不占空间的。

【例2.19】　类中有虚的析构函数的空间计算。

#include<iostream>

using namespace std;

class CBox{

public:

CBox(){};

virtual ~CBox(){};

};

int main(){

CBox boxobj;

cout<<sizeof(boxobj)<<endl; // 输出4

return 0;

}

程序的执行结果是：

例2.19中，类CBox中有1个构造函数和1个虚的析构函数，程序的执行结果是8。事实上，编译器为了支持虚函数，会产生额外的负担，这正是指向虚函数表的指针的大小。（指针变量在64位的机器上占8Byte。）如果一个类中有一个或者多个虚函数，没有成员变量，那么类相当于含有一个指向虚函数表的指针，占8Byte。

【例2.20】　继承空类和多重继承空类存储空间的计算。

#include<iostream>

using namespace std;

class A{

};

class B{

};

class C:public A{

};

class D:public virtual B{

};

class E:public A,public B{

};

int main(){

A a;

B b;

C c;

D d;

E e;

cout<<"sizeof(a):"<<sizeof(a)<<endl;

cout<<"sizeof(b):"<<sizeof(b)<<endl;

cout<<"sizeof(c):"<<sizeof(c)<<endl;

cout<<"sizeof(d):"<<sizeof(d)<<endl;

cout<<"sizeof(e):"<<sizeof(e)<<endl;

return 0;

}

程序的执行结果是：

sizeof(a):1

sizeof(b):1

sizeof(c):1

sizeof(d):8

sizeof(e):1

例2.20中定义了一个空类A和B，类C继承了类A，类D继承了虚基类B，类E继承了类A和类B。这些类的对象所占的空间都是1Byte。由此可见，单一继承的空类空间也是1，多重继承的空类空间还是1，但是虚继承涉及虚表（虚指针），所以sizeof(d)=8。

综上所述，每个对象所占用的存储空间只是该对象的非静态数据成员的总和，其他都不占用存储空间，包括成员函数和静态数据成员。函数代码是存储在对象空间之外的，而且，函数代码段是公用的，即如果对同一个类定义了10个对象，这些对象的成员函数对应的是同一个函数代码段，而不是10个不同的函数代码段。

9.?this指针

每个对象中的数据成员都分别占有存储空间，如果对同一个类定义了n个对象，则有n组同样大小的空间以存放n个对象中的数据成员。不同对象都调用同一个函数代码段。那么，当不同对象的成员函数引用数据成员时，怎么能保证所引用的是所指定的对象的数据成员呢？

假设，对于上述例子中定义的Box类，定义了3个同类对象a、b、c。如果有a.volume( )，应该是引用对象a中的height、width和length，以计算出箱子a的体积；如果有b.volume( )，应该是引用对象b中的height、width和length，计算出箱子b的体积。而现在都用同一个函数段，系统怎样使它分别引用a或b中的数据成员呢？

在每一个成员函数中都包含一个特殊的指针，这个指针的名字是固定的，称为this指针。它是指向本类对象的指针，它的值是当前被调用的成员函数所在的对象的起始地址。例如，当调用成员函数a.volume时，编译系统就把对象a的起始地址赋给this指针，在成员函数引用数据成员时，就按照this的指向找到对象a的数据成员。例如volume函数要计算height*width*length的值，实际上是执行：

(this->height)*(this->width)*(this->length)

由于当前this指向a，因此相当于执行：

(a.height)*(a.width)*( a.length)

这就计算出箱子a的体积。同样如果有b.volume()，编译系统就把对象b的起始地址赋给成员函数volume的this指针，显然计算出来的是箱子b的体积。

this指针是隐式使用的，它是作为参数被传递给成员函数。本来，成员函数volume的定义如下：

int Box::volume(){

return (height*width*length);

}

C++把它处理为：

int Box::volume(Box *this){

return (this->height * this->width * this->length);

}

即在成员函数的形参表列中增加一个this指针。在调用该成员函数时，实际上是用以下方式调用的：

a.volume(&a);

将对象a的地址传给形参this指针，然后按this的指向去引用其他成员。

需要说明的是，这些都是编译系统自动实现的，不必人为地在形参中增加this指针，也不必将对象a的地址传给this指针，但在需要时也可以显式地使用this指针。

例如在Box类的volume函数中，下面两种表示方法都是合法的、相互等价的：

return (height * width * length); // 隐含使用this指针

return (this->height * this->width * this->length); // 显式使用this指针

可以用*this表示被调用的成员函数所在的对象，*this就是this所指向的对象，即当前的对象。例如在成员函数a.volume( )的函数体中，如果出现*this，它就是对象a。上面的return语句也可写成：

return((*this).height * (*this).width * (*this).length);

*this两侧的括号不能省略，不能写成*this.height。因为成员运算符“.”的优先级别高于指针运算符“*”，因此，* this.height就相当于* (this.height)，而this.height是不合法的，编译会出错。

所谓“调用对象a的成员函数f”，实际上是在调用成员函数f时使this指针指向对象a，从而访问对象a的成员。在使用“调用对象a的成员函数f”时，应当对它的含义有正确的理解。

this指针有以下特点。

（1）只能在成员函数中使用，在全局函数、静态成员函数中都不能使用this。

（2）this指针是在成员函数的开始前构造，并在成员函数的结束后清除。

（3）this指针会因编译器不同而有不同的存储位置，可能是栈、寄存器或全局变量。

（4）this是类的指针。

（5）因为this指针只有在成员函数中才有定义，所以获得一个对象后，不能通过对象使用this指针，所以也就无法知道一个对象的this指针的位置。不过，可以在成员函数中指定this指针的位置。

（6）普通的类函数（不论是非静态成员函数，还是静态成员函数）都不会创建一个函数表来保存函数指针，只有虚函数才会被放到函数表中。

10.?类模板

有时，两个或多个类的功能是相同的，但仅仅因为数据类型不同，就要分别定义两个类，如下面的例2.21声明了一个类。

【例2.21】　操作整数的类。

class Operation_int{

public:

Operation_int(int a,int b):x(a),y(b){}

int add(){

return x+y;

}

int subtract(){

return x-y;

}

private:

int x,y;

};

这个类的作用是两个整数的加减，如果要对两个浮点数做加减，就又得新定义一个类，比如例2.22所示。

【例2.22】　操作浮点数的类。

class Operation_double{

public:

Operation_double(double a, double b):x(a),y(b){}

double add(){

return x+y;

}

double subtract(){

return x-y;

}

private:

double x,y;

};

因为参数的类型不同，所以不能复用，这也使得代码量剧增。为了解决这类问题，C++中提供了类模板的功能。可以先声明一个通用的类模板，这个类模板可以有一个或多个虚拟的类型参数，对以上例子中的两个类，可以定义如例2.23这样的类模板。

【例2.23】　操作两个数的类模板。

template<class T> // 声明一个模板，虚拟类型名为T

class Operation {

public:

Operation (T a, T b):x(a),y(b){}

T add(){

return x+y;

}

T subtract(){

return x-y;

}

private:

T x,y;

};

例2.23这个类模板与上面的类相比，有以上两个不同点。

（1）声明类模板时增加了下面这一行代码：

template <class 类型参数名>

其中，template是声明类模板时必须写的关键字，意思是“模板”。关键字class后的类型参数名可以是任意的合法标识符，本例中T就是一个类型参数名。

（2）原有的类型名int换成虚拟类型参数名T。

在建立类对象时，如果将实际类型指定为int型，编译系统就会用int取代T；如果指定为double，编译系统就会用double取代T。

声明一个类模板的对象时，要用实际类型名去取代虚拟的类型，这样才能使它变成一个实际的对象，如：

Operation <int> opobj(1,2);

在类模板名之后的尖括号里指定实际的类型名，这样在编译时，编译系统就用int取代类模板中的类型参数T，这样就把类模板具体化了，或者说实际化了。例2.24中实现了一个类模板，利用它可以分别对两个整数和两个浮点数进行加、减操作。

【例2.24】　用类模板实现对两个数的加、减操作。

#include <iostream>

using namespace std;

template<class T> // 声明一个模板，虚拟类型名为T

class Operation {

public:

Operation (T a, T b):x(a),y(b){}

T add(){

return x+y;

}

T subtract(){

return x-y;

}

private:

T x,y;

};

int main(){

Operation <int> op_int(1,2);

cout<<op_int.add()<<" "<<op_int.subtract()<<endl; // 输出3、-1

Operation <double> op_double(1.2,2.3);

cout<<op_double.add()<<" "<<op_double.subtract()<<endl; // 输出3.5、-1.1

return 0;

}

程序的执行结果是：

3 -1

3.5 -1.1

例2.24中声明了一个类模板，可以对两个相同类型的数进行加、减操作：如果是传入两个整数，则对两个整数进行加减；如果传入两个浮点数，则对两个浮点数进行加减。

如果类模板的成员函数是在类外定义的，则需要这么写：

template<class T>

T Operation <T> :: add(){

return x+y;

}

综上所述，可以这样声明和使用类模板。

（1）先写一个实际的类。

（2）将此类中准备改变的类型名改用一个自己指定的虚拟类型名。

（3）在类声明前面加入一行，格式为：template<class虚拟类型参数>。

（4）用类模板定义对象时用以下形式：

类模板名<实际类型名>对象名；

类模板名<实际类型名>对象名(实参表列)；

（5）如果在类模板外定义成员函数，应写成类模板形式：

template <class 虚拟类型参数>

函数类型类模板名<虚拟类型参数>::成员函数名(函数形参表列) {…}

类模板是对一批仅数据成员类型不同的类的抽象，只要为这一批类所组成的整个类家族创造一个类模板，即给出一套程序代码，就可以用来生成多种具体的类，从而大大提高编程的效率。

11.?析构函数与构造函数的执行顺序

前面讲了析构函数执行的时机，下面再来对比下构造函数和析构函数的调用时间和调用顺序。首先看下面包含构造函数和析构函数的C++程序的执行结果，以此来判断二者执行的顺序。

【例2.25】　构造函数和析构函数的执行顺序实例。

#include<iostream>

using namespace std;

class CBox{

public:

CBox (int h,int w,int l){

height=h;

width=w;

length=l;

cout<<"Constructor called."<<endl; // 构造函数被执行时输出信息

}

~CBox (){ // 析构函数

cout<<"Destructor called."<<length<<endl; // 析构函数被执行时输出

}

int volume(){

return height*width*length;

}

private:

int height,width,length;

};

int main(){

CBox box1(1,2,3);

cout<<box1.volume()<<endl;

CBox box2(2,3,4);

cout<<box2.volume()<<endl;

return 0;

}

程序的执行结果为：

Constructor called.

Destructor called.4

Destructor called.3

例2.25中声明了类CBox，类中有一个构造函数和一个析构函数，当构造函数运行时会输出一句话，方便判断构造函数执行的时机；同样的，当析构函数运行时也会输出一句话，方便判断析构函数执行的时机。

在一般情况下，调用析构函数的次序正好与调用构造函数的次序相反：最先被调用的构造函数，其对应的（同一对象中的）析构函数最后被调用；而最后被调用的构造函数，其对应的析构函数最先被调用。如上所示，先执行box2的析构函数，再执行box1的析构函数。可以简记为：先构造的后析构，后构造的先析构，它相当于一个栈，先进后出。但是，并不是在任何情况下都是按这一原则处理的。对象可以在不同的作用域中定义，可以有不同的存储类别，这些都会影响调用构造函数和析构函数的时机。下面归纳一下什么时候调用构造函数和析构函数。

（1）在全局范围中定义的对象（即在所有函数之外定义的对象），它的构造函数在文件中的所有函数（包括main函数）执行之前调用。但如果一个程序中有多个文件，而不同的文件中都定义了全局对象，则这些对象的构造函数的执行顺序是不确定的。当main函数执行完毕或调用exit函数时（此时程序终止），调用析构函数。

（2）如果定义的是局部自动对象（如在函数中定义对象），则在建立对象时调用其构造函数。如果函数被多次调用，则在每次建立对象时都要调用构造函数。在函数调用结束、对象释放时先调用析构函数。

（3）如果在函数中定义静态（static）局部对象，则只在程序第一次调用此函数建立对象时调用构造函数一次，在调用结束时对象并不释放，因此也不调用析构函数，只在main函数结束或调用exit函数结束程序时，才调用析构函数。例如，在一个函数中定义了以下两个对象：

void func(){

Box box1; // 定义自动局部对象

static Box box2; // 定义静态局部对象

}

在调用func函数时，先调用box1的构造函数，再调用box2的构造函数。在func调用结束时，box1是要释放的（因为它是自动局部对象），因此要调用box1的析构函数。而box2是静态局部对象，在func调用结束时并不需要释放，因此不需要调用stud2的析构函数，直到程序结束释放stud2时，才调用stud2的析构函数。由此可以看到，stud2是后调用构造函数的，但并不先调用其析构函数，原因是两个对象的存储类别、生命周期都不同。

2.2　继承与派生

1.?继承与派生的一般形式

继承与派生在C++中也是经常使用的，比如设计一个箱子类可以用以下代码实现：

Class CBox{

public:

int volume(){

return height*width*length;

}

void display(){

cout<<height<<endl;

cout<<width<<endl;

cout<<length<<endl;

}

private:

int height,width,length;

};

但假设现在有一批箱子比较特殊，有不同的颜色，且重量也都不一样，此时可以重新声明一个新的箱子的类，如下所示：

Class CBox_new{

public:

int volume(){

return height*width*length;

}

void display(){

cout<<height<<endl;

cout<<width<<endl;

cout<<length<<endl;

cout<<color<<endl;

cout<<weight<<endl;

}

private:

int height,width,length;

int color,weight;

};

可以看到上面的程序中有相当一部分是原来就已经有的，其实可以利用原来的CBox类作为基础，再加上新的内容即可，如下所示：

Class CBox_new::public CBox{ // 类CBox_new继承于类CBox

public:

void display1(){ // 新增加的成员函数

cout<<color<<endl;

cout<<weight<<endl;

}

private:

int color,weight; // 新增加的成员变量

};

这里，Box_new就是一个派生类。可见，声明派生类的一般形式为：

class 派生类名:［继承方式］基类名{

派生类新增加的成员

};

其中的继承方式包括public（公用的）、private（私有的）和protected（受保护的），此项是可选的，如果不写此项，则默认为private（私有的）。

派生类里有两大部分内容：从基类继承而来的和在声明派生类时增加的部分。派生类中接受了基类的全部内容，这样可能出现有些基类的成员，在派生类中是用不到的，但是也必须继承过来的情况。这就会造成数据的冗余，尤其多次派生后，会在许多派生类对象中存在大量无用的数据，不仅浪费了大量的空间，而且在对象的建立、赋值、复制和参数的传递中，花费许多无谓的时间，从而降低了效率。因此，实际开发中要根据派生类的需要慎重选择基类，使冗余量最小。

2.?派生类的访问属性

（1）派生类中包含基类成员和派生类自己增加的成员，就产生了这两部分成员的关系和访问属性的问题。在建立派生类的时候，并不是简单地把基类的私有成员直接作为派生类的私有成员，把基类的公用成员直接作为派生类的公用成员；实际上，对基类成员和派生类自己增加的成员是按不同的原则处理的。具体来说，在讨论访问属性时，要考虑以下几种情况。

1）基类的成员函数只能访问基类的成员，而不能访问派生类的成员。

2）派生类的成员函数可以访问基类的成员，具体见后面详细描述；派生类的成员函数也可以访问派生类成员。

3）在派生类外可以访问基类的成员，具体见后面详细描述；在派生类外也可以访问派生类的公用成员，而不能访问派生类的私有成员。

（2）派生类的成员函数访问基类的成员和在派生类外访问基类的成员涉及如何确定基类的成员在派生类中的访问属性的问题，不仅要考虑对基类成员所声明的访问属性，还要考虑派生类所声明的对基类的继承方式，根据这两个因素共同决定基类成员在派生类中的访问属性。在派生类中，对基类的继承方式可以有public（公用的）、private（私有的）和protected（保护的）3种。不同的继承方式决定了基类成员在派生类中的访问属性。简单地说可以总结为以下几点。

1）公用继承（public inheritance）：基类的公用成员和保护成员在派生类中保持原有访问属性，其私有成员仍为基类私有。

2）私有继承（private inheritance）：基类的公用成员和保护成员在派生类中成了私有成员，其私有成员仍为基类私有。

3）受保护的继承（protected inheritance）：基类的公用成员和保护成员在派生类中成了保护成员，其私有成员仍为基类私有。保护成员的意思是，不能被外界引用，但可以被派生类的成员引用。

在多级派生的情况下，各成员的访问属性仍按以上原则确定。假设类A为基类，类B是类A的派生类，类C是类B的派生类，则类C也是类A的派生类；类B称为类A的直接派生类，类C称为类A的间接派生类；类A是类B的直接基类，是类C的间接基类。派生关系如图2-3所示。

如果声明了以下的类：

class A{

public:

int var_A_pub;

protected:

void func_A_pro();

int var_A_pro;

private:

int var_A_pri;

};

class B:public A{

public:

void func_B_pub();

protect:

void func_B_pro();

private:

int var_B_pri;

};

class C:protected B{

public:

void func_C_pub();

private:

int var_C_pri;

};

则类A是类B的公用基类，类B是类C的保护基类。各成员在不同类中的访问属性如表2-1所示。

表2-1　派生的各个成员的访问属性

var_A_pub func_A_pro var_A_pro var_A_pri func_B_pub func_B_pro var_B_pri func_C_pub var_C_pri

基类A 公用保护保护私有

公用派生类B 公用保护保护不可访问公用保护私有

保护派生类C 保护保护保护不可访问保护保护不可访问公用私有

通过以上分析，可以看到：无论哪一种继承方式，在派生类中是不能访问基类的私有成员的，私有成员只能被本类的成员函数所访问，毕竟派生类与基类不是同一个类。如果在多级派生时都采用公用继承方式，那么直到最后一级派生类都能访问基类的公用成员和保护成员。如果采用私有继承方式，经过若干次派生之后，基类的所有成员就会变成不可访问的了。如果采用保护继承方式，在派生类外是无法访问派生类中的任何成员的；而且经过多次派生后，人们很难清楚地记住哪些成员可以访问，哪些成员不能访问，很容易出错。因此，在实际中，常用的是公用继承。

3.?派生类的构造函数与析构函数

派生类的数据成员由所有基类的数据成员与派生类新增的数据成员共同组成，如果派生类新增成员中包括其他类的对象（子对象），派生类的数据成员中实际上还间接地包括了这些对象的数据成员。因此，构造派生类的对象时，必须对基类数据成员、新增数据成员和成员对象的数据成员进行初始化。派生类的构造函数必须要以合适的初值作为参数，隐含调用基类和新增对象成员的构造函数，来初始化它们各自的数据成员，然后再加入新的语句对新增普通数据成员进行初始化。

派生类构造函数的一般格式如下：

<派生类名>::<派生类名>(<参数表>) : <基类名1>(<参数表1>),

……,

<基类名n>(<参数表n>),

<子对象名1>(<参数表n+1>),

……,

<子对象名m>(<参数表n+m>) {

<派生类构造函数体> // 派生类新增成员的初始化

}

对派生类的构造函数有以下几点说明：

（1）对基类成员和子对象成员的初始化必须在成员初始化列表中进行，新增成员的初始化既可以在成员初始化列表中进行，也可以在构造函数体中进行。

（2）派生类构造函数必须对这3类成员进行初始化，其执行顺序是这样的：①先调用基类构造函数；②再调用子对象的构造函数；③最后调用派生类的构造函数体。

（3）当派生类有多个基类时，处于同一层次的各个基类的构造函数的调用顺序取决于定义派生类时声明的顺序（自左向右），而与在派生类构造函数的成员初始化列表中给出的顺序无关。

（4）如果派生类的基类也是一个派生类，则每个派生类只需负责其直接基类的构造，依次上溯。

（5）当派生类中有多个子对象时，各个子对象构造函数的调用顺序也取决于在派生类中定义的顺序（自前至后），而与在派生类构造函数的成员初始化列表中给出的顺序无关。

（6）派生类构造函数提供了将参数传递给基类构造函数的途径，以保证在基类进行初始化时能够获得必要的数据。因此，如果基类的构造函数定义了一个或多个参数时，派生类必须定义构造函数。

（7）如果基类中定义了默认构造函数或根本没有定义任何一个构造函数（此时由编译器自动生成默认构造函数）时，在派生类构造函数的定义中可以省略对基类构造函数的调用，即省略"<基类名>(<参数表>)"这个语句。

（8）子对象的情况与基类相同。

（9）当所有的基类和子对象的构造函数都可以省略时，可以省略派生类构造函数的成员初始化列表。

（10）如果所有的基类和子对象构造函数都不需要参数，派生类也不需要参数时，派生类构造函数可以不定义。派生类构造函数的使用可以参考例2.26的程序。

【例2.26】　派生类构造函数的使用举例。

#include<iostream>

#include<string>

using namespace std;

class CStudent{ // 声明基类Student

public:

CStudent(int n,string nam,char s){ // 基类构造函数

num=n;

name=nam;

sex=s;

}

~CStudent(){} // 基类析构函数

protected: // 保护部分

int num;

string name;

char sex ;

};

class CStudent1: public CStudent{ // 声明派生类Student1

public : // 派生类的公用部分

CStudent1 (int n,string nam,char s,int a,string ad): CStudent (n,nam,s){

// 派生类构造函数

age=a; // 在函数体中只对派生类新增的数据成员初始化

addr=ad;

}

void show(){

cout<<"num: "<<num<<endl;

cout<<"name: "<<name<<endl;

cout<<"sex: "<<sex<<endl;

cout<<"age: "<<age<<endl;

cout<<"address: "<<addr<<endl<<endl;

}

~CStudent1(){ } // 派生类析构函数

private : // 派生类的私有部分

int age;

string addr;

};

int main(){

CStudent1 stud1(10010,"Wang-li",'f',19,"115 Beijing Road,Shanghai");

CStudent1 stud2(10011,"Zhang-fun",'m',21,"213 Shanghai Road,Beijing");

stud1.show(); // 输出第一个学生的数据

stud2.show(); // 输出第二个学生的数据

return 0;

}

程序的执行结果是：

num: 10010

name: Wang-li

sex: f

age: 19

address: 115 Beijing Road,Shanghai

num: 10011

name: Zhang-fun

sex: m

age: 21

address: 213 Shanghai Road,Beijing

例2.26中定义了类CStudent、类CStudent1，其中类CStudent1继承了类CStudent。类CStudent1比基类新增了两个数据成员。基类CStudent有自己的带参构造函数，而派生类的构造函数，则只须对派生类新增的数据成员初始化，不过需要把基类的参数也给带进去。

析构函数的作用是在对象撤销之前，进行必要的清理工作。当对象被删除时，系统会自动调用析构函数。

析构函数比构造函数简单，没有类型，也没有参数。在派生时，派生类是不能继承基类的析构函数的，也需要通过派生类的析构函数去调用基类的析构函数。在派生类中可以根据需要定义自己的析构函数，用来对派生类中所增加的成员进行清理工作；基类的清理工作仍然由基类的析构函数负责。在执行派生类的析构函数时，系统会自动调用基类的析构函数和子对象的析构函数，对基类和子对象进行清理。

4.?派生类的构造函数与析构函数的调用顺序

前面已经提到，构造函数和析构函数的调用顺序是先构造的后析构，后构造的先析构。那么基类和派生类中的构造函数和析构函数的调用顺序是否也是如此呢？

构造函数的调用顺序规则如下所述。

1）基类构造函数。如果有多个基类，则构造函数的调用顺序是某类在类派生表中出现的顺序，而不是它们在成员初始化表中的顺序。

2）成员类对象构造函数。如果有多个成员类对象，则构造函数的调用顺序是对象在类中被声明的顺序，而不是它们出现在成员初始化表中的顺序。

3）派生类构造函数。

而析构函数的调用顺序与构造函数的调用顺序正好相反，将上面3点内容中的顺序反过来用就可以了，即：首先调用派生类的析构函数；其次再调用成员类对象的析构函数；最后调用基类的析构函数。析构函数在下面3种情况时被调用。

1）对象生命周期结束被销毁时（一般类成员的指针变量与引用都不自动调用析构函数）。

2）delete指向对象的指针时，或delete指向对象的基类类型指针，而其基类虚构函数是虚函数时。

3）对象i是对象o的成员，o的析构函数被调用时，对象i的析构函数也被调用。

下面用例2.27来说明构造函数的调用顺序。

【例2.27】　构造函数的调用顺序。

#include<iostream>

using namespace std;

class CBase{

public:

CBase (){ std::cout<<"CBase::CBase()"<<std::endl; }

~ CBase (){ std::cout<<"CBase::~CBase()"<<std::endl; }

};

class CBase1:public CBase {

public:

CBase1 (){ std::cout<<"CBase::Base1()"<<std::endl; }

~ CBase1 (){ std::cout<<"CBase::~Base1()"<<std::endl; }

};

class CDerive{

public:

CDerive (){ std::cout<<"CDerive::CDerive()"<<std::endl; }

~ CDerive (){ std::cout<<"CDerive::~CDerive()"<<std::endl; }

};

class CDerive1:public CBase1{

private:

CDerive m_derive;

public:

CDerive1(){ std::cout<<"CDerive1::CDerive1()"<<std::endl; }

~CDerive1(){ std::cout<<"CDerive1::~CDerive1()"<<std::endl; }

};

int main(){

CDerive1 derive;

return 0;

}

程序的执行结果是：

CBase::CBase()

CBase::Base1()

CDerive::CDerive()

CDerive1::CDerive1()

CDerive1::~CDerive1()

CDerive::~CDerive()

CBase::~Base1()

CBase::~CBase()

例2.27中声明了4个类，CBase1继承于CBase、CDerive1继承于CBase1、CDerive1中有CDerive的成员变量，最后定义一个CDerive1对象，用来确定各种基类、派生类的构造函数和析构函数的执行顺序。执行结果与上文中描述的调用顺序相符。

总的来说，构造函数的调用顺序是：①如果存在基类，那么先调用基类的构造函数，如果基类的构造函数中仍然存在基类，那么程序会继续进行向上查找，直到找到它最早的基类进行初始化（如上例中类Derive1，继承于类Base与Base1）；②如果所调用的类中定义的时候存在对象被声明，那么在基类的构造函数调用完成以后，再调用对象的构造函数（如上例在类Derive1中声明的对象Derive m_derive）；③调用派生类的构造函数（如上例最后调用的是Derive1类的构造函数）。

2.3　类的多态

1.?多态

多态，顾名思义，是一个事物有多种形态的意思。在C++程序设计中，多态性是指具有不同功能的函数可以用同一个函数名，这样就可以用一个函数名调用不同内容的函数。在面向对象方法中一般是这样表述多态性的：向不同的对象发送同一个消息，不同的对象在接收时会产生不同的行为（即方法）；也就是说，每个对象可以用自己的方式去响应共同的消息。所谓消息，就是调用函数，不同的行为就是指不同的实现，即执行不同的函数。

【例2.28】　基类和派生类成员函数同名覆盖时的执行选择。

#include<iostream>

using namespace std;

class A{

public:

A(){}

virtual void foo(){

cout<<"This is A."<<endl;

}

};

class B : public A{

public:

B(){}

void foo(){

cout<<"This is B."<<endl;

}

};

int main(){

A a;

a.foo();

B b;

b.foo();

return 0;

}

程序的执行结果：

This is A.

This is B.

例2.28中声明了两个类（类A和类B），注意类A中的foo函数和类B中的foo函数不是重载函数，它们不仅函数名相同，而且函数类型和参数个数都相同，但两个同名函数不在同一个类中，而是分别在基类和派生类中，属于同名覆盖。若是重载函数，二者的参数个数和参数类型必须至少有一者不同，否则系统无法确定调用哪一个函数。而此处定义了一个A类的对象a和B类的对象b，有所区别，所以会分别执行各个类的foo函数。

人们提出这样的设想，能否用同一个调用形式，既能调用派生类又能调用基类的同名函数。在程序中不是通过不同的对象名去调用不同派生层次中的同名函数，而是通过指针调用它们。C++中的虚函数就是用来解决这个问题的。虚函数的作用是允许在派生类中重新定义与基类同名的函数，并且可以通过基类指针或引用来访问基类和派生类中的同名函数。

再看下面的例2.29，基类和派生类中有同名的函数display，就是使用虚函数，使得基类指针可以访问派生类中的同名函数。

【例2.29】　使用虚函数可以使得基类指针访问派生类中的同名函数。

#include <iostream>

#include <string>

using namespace std;

/*声明基类Box*/

class Box{

public:

Box(int,int,int); // 声明构造函数

virtual void display(); // 声明输出函数

protected: // 受保护成员，派生类可以访问

int length,height,width;

};

/*Box类成员函数的实现*/

Box:: Box (int l,int h,int w){ // 定义构造函数

length =l;

height =h;

width =w;

}

void Box::display(){ // 定义输出函数

cout<<"length:" << length <<endl;

cout<<"height:" << height <<endl;

cout<<"width:" << width <<endl;

}

/*声明公用派生类FilledBox*/

class FilledBox : public Box{

public:

FilledBox (int, int, int, int, string); // 声明构造函数

virtual void display(); // 虚函数

private:

int weight; // 重量

string fruit; // 装着的水果

};

/* FilledBox类成员函数的实现*/

void FilledBox :: display(){ // 定义输出函数

cout<<"length:"<< length <<endl;

cout<<"height:"<< height <<endl;

cout<<"width:"<< width <<endl;

cout<<"weight:"<< weight <<endl;

cout<<"fruit:"<< fruit <<endl;

}

FilledBox:: FilledBox (int l, int h, int w, int we, string f ) : Box(l,h,w), weight(we),

fruit(f){}

int main(){ // 主函数

Box box(1,2,3); // 定义Student类对象stud1

FilledBox fbox(2,3,4,5,"apple"); // 定义FilledBox类对象fbox

Box *pt = &box; // 定义指向基类对象的指针变量pt

pt->display( );

pt = &fbox;

pt->display( );

return 0;

}

程序的执行结果是：

length:1

height:2

width:3

length:2

height:3

width:4

weight:5

fruit:apple

例2.25中声明了一个类Box和一个继承于类Box的类FilledBox。类Box中有一个成员函数display，类FilledBox中也有一个成员函数display，现在将基类Box中的成员函数display定义为虚函数，就能使得基类对象的指针变量既可以访问基类的成员函数display，也可以访问派生类的成员函数display。

例2.25就展现了虚函数的奇妙作用。现在用同一个指针变量（指向基类对象的指针变量），不但输出了box的全部数据，而且还输出了fbox的全部数据，这就说明已调用了fbox的display函数。这表明用同一种调用形式"pt->display()"，而且pt是同一个基类指针，也可以调用同一类族中不同类的虚函数。这就是多态性，即对同一消息，不同对象有不同的响应方式。

说明：本来基类指针是用来指向基类对象的，如果用它指向派生类对象，则需要进行指针类型转换，即将派生类对象的指针先转换为基类的指针，所以基类指针指向的是派生类对象中的基类部分。如果基类中的display函数不是虚函数，是无法通过基类指针去调用派生类对象中的成员函数的。虚函数突破了这一限制，在派生类的基类部分中，派生类的虚函数取代了基类原来的虚函数，因此在使基类指针指向派生类对象后，调用虚函数时就调用了派生类的虚函数。要注意的是，只有用virtual声明了虚函数后才具有以上作用，如果不声明为虚函数，企图通过基类指针调用派生类的非虚函数则是不行的。

当把基类的某个成员函数声明为虚函数后，就允许在其派生类中对该函数重新定义，赋予它新的功能，并且可以通过指向基类的指针指向同一类族中不同类的对象，从而调用其中的同名函数。虚函数实现了同一类族中不同类的对象可以对同一函数调用作出不同的响应的动态多态性。

虚函数的使用方法如下所述。

（1）在基类用virtual关键字声明成员函数为虚函数。

这样就可以在派生类中重新定义此函数，为它赋予新的功能，并能方便地被调用。在类外定义虚函数时，不必再加virtual关键字。

（2）在派生类中重新定义此函数，要求函数名、函数类型、函数参数个数和类型全部与基类的虚函数相同，并根据派生类的需要重新定义函数体。

C++规定，当一个成员函数被声明为虚函数后，其派生类中的同名函数都自动成为虚函数。因此在派生类重新声明该虚函数时，可以加virtual关键字，也可以不加，但一般习惯在每一层声明该函数时都加virtual关键字，使程序更加清晰。如果在派生类中没有对基类的虚函数重新定义，则派生类简单地继承其直接基类的虚函数。

（3）定义一个指向基类对象的指针变量，并使它指向同一类族中需要调用该函数的对象。

通过该指针变量调用此虚函数，此时调用的就是指针变量指向的对象的同名函数。

（4）通过虚函数与指向基类对象的指针变量的配合使用，就能方便地调用同一类族中不同类的同名函数，只要先用基类指针指向即可。如果指针不断地指向同一类族中不同类的对象，就能不断地调用这些对象中的同名函数。正如前面所说，不断地告诉出租车司机要去的目的地，然后司机把你送到你要去的地方。

需要说明以下几点：①有时在基类中定义的非虚函数会在派生类中被重新定义，如果用基类指针调用该成员函数，则系统会调用对象中基类部分的成员函数；②如果用派生类指针调用该成员函数，则系统会调用派生类对象中的成员函数，这并不是多态性行为（使用的是不同类型的指针），没有用到虚函数的功能。

2.?虚函数的使用

（1）使用虚函数时，有两点要注意，如下所述。

1）只能用virtual关键字声明类的成员函数，使它成为虚函数，而不能将类外的普通函数声明为虚函数。因为虚函数的作用是允许在派生类中对基类的虚函数重新定义。显然，它只能用于类的继承层次结构中。

2）一个成员函数被声明为虚函数后，在同一类族中的类就不能再定义一个非virtual的但与该虚函数具有相同的参数（包括个数和类型）和函数返回值类型的同名函数。

（2）根据什么考虑是否把一个成员函数声明为虚函数呢？主要考虑以下几点。

1）首先看成员函数所在的类是否会作为基类。然后看成员函数在类的继承后有无可能被更改功能，如果希望更改其功能，一般应该将它声明为虚函数。

2）如果成员函数在类被继承后的功能不需要被修改，或派生类用不到该函数，则不要把它声明为虚函数。不要仅仅考虑到要作为基类而把类中的所有成员函数都声明为虚函数。

3）应考虑对成员函数的调用是通过对象名还是通过基类指针或引用去访问，如果是通过基类指针或引用去访问的，则应当声明为虚函数。

4）有时，在定义虚函数时并不定义其函数体，即函数体是空的。它的作用只是定义了一个虚函数名，具体功能留给派生类去添加。

需要说明的是：使用虚函数，系统要有一定的空间开销。当一个类带有虚函数时，编译系统会为该类构造一个虚函数表，它是一个指针数组，用于存放每个虚函数的入口地址。系统在进行动态关联时的时间开销是很少的，因此，多态是高效的。

3.?纯虚函数

纯虚函数是在基类中声明的虚函数，它在基类中没有定义，但要求任何派生类都要定义自己的实现方法。在基类中实现纯虚函数的方法是在函数原型后加“=0”，如下所示：

virtual void funtion()=0;

而虚函数的定义是：

virtual void funtion();

为了方便使用多态特性，常常需要在基类中定义虚函数。但在很多情况下，用基类本身生成对象是不合情理的。例如，动物作为一个基类可以派生出老虎、孔雀等子类，但用动物本身生成对象明显不合常理。为了解决上述问题，从而引入了纯虚函数的概念，将函数定义为纯虚函数，则编译器要求在派生类中必须予以重载以实现多态性。同时含有纯虚函数的类称为抽象类，它不能生成对象。如果一个类中含有纯虚函数，那么任何试图对该类进行实例化的语句都是错误的，因为抽象基类是不能被直接调用的，而必须被子类继承重载以后，再根据要求调用其子类的方法，且在子类中一定要实现纯虚函数的定义，不然编译时会出错。

【例2.30】　纯虚函数的使用举例。

class Animail{

public:

virtual void GetColor() = 0;

};

class Dog : public Animail{

public:

virtual void GetColor() {cout <<"Yellow"endl;};

};

class Pig : public Animail{

public:

virtual void GetColor() {cout <<"White"<<endl;};

};

int main(){

Animail cAnimail;

return 0;

}

该程序编译失败，因为在例2.30中声明了一个动物类（Animail），类中有一函数GetColor可取得动物颜色，但动物有很多很多种，颜色自然无法确定，所以就把它声明为纯虚函数，也就是只声明函数名不去定义（实现）它，不能通过编译。有一点需要注意，纯虚函数不能实例化，但可以声明指针，所以上面的程序编译时，编译器会告诉你：由于它的成员的原因，无法抽象类Animail，并且警告你GetColor()没有定义，所以报错。

4.?析构函数

在C++中，构造函数不能声明时为虚函数，这是因为编译器在构造对象时，必须知道确切类型，才能正确地生成对象；其次，在构造函数执行之前，对象并不存在，无法使用指向此对象的指针来调用构造函数。然而，析构函数可以声明为虚函数；C++明确指出，当derived class对象经由一个base class指针被删除、而该base class带着一个non-virtual析构函数，会导致对象的derived成分没被销毁掉，如例2.31所示。

【例2.31】　析构函数不是虚函数容易引发内存泄漏。

#include<iostream>

using namespace std;

class Base{

public:

Base(){ std::cout<<"Base::Base()"<<std::endl; }

~Base(){ std::cout<<"Base::~Base()"<<std::endl; }

};

class Derive:public Base{

public:

Derive(){ std::cout<<"Derive::Derive()"<<std::endl; }

~Derive(){ std::cout<<"Derive::~Derive()"<<std::endl; }

};

int main(){

Base* pBase = new Derive();

/*这种base classed的设计目的是为了用来“通过base class接口处理derived class对象”*/

delete pBase;

return 0;

}

程序的执行结果是：

Base::Base()

Derive::Derive()

Base::~Base()

例2.31中声明了两个类Base和类Derive，类Derive继承于类Base，两个类各自有构造函数和析构函数，并且基类和派生类的析构函数都是非虚函数。从上面的执行结果可以看出，析构函数的调用结果是存在问题的，也就是说析构函数只做了局部销毁工作，这可能形成资源泄漏、损坏数据结构等问题。而解决此问题的方法很简单，只要给基类一个virtual析构函数即可，如例2.32所示。

【例2.32】　基类的析构函数为虚函数。

#include<iostream>

using namespace std;

class Base{

public:

Base(){ std::cout<<"Base::Base()"<<std::endl; }

virtual ~Base(){ std::cout<<"Base::~Base()"<<std::endl; }

};

class Derive:public Base{

public:

Derive(){ std::cout<<"Derive::Derive()"<<std::endl; }

~Derive(){ std::cout<<"Derive::~Derive()"<<std::endl; }

};

int main(){

Base* pBase = new Derive();

delete pBase;

return 0;

}

输出结果是：

Base::Base()

Derive::Derive()

Derive::~Derive()

Base::~Base()

例2.32与例2.31的区别只在于是否把基类的析构函数声明为虚函数。例2.32中派生类和基类都能正常析构了，这样的结果正是我们所希望的。虚函数是多态的基础，在C++中没有虚函数就无法实现多态特性；因为不声明为虚函数就不能实现“动态联编”，就不能实现多态。

5.?单例模式

要理解单例模式，只需要一个实例就可以了。比如，一台计算机上可以连好几台打印机，但是这个计算机上的打印程序只能有一个，这里就可以通过单例模式来避免两个打印作业同时输出到打印机中，即在整个的打印过程中只有一个打印程序的实例。对于这种问题，《设计模式》一书中给出了一种很不错的实现，定义一个单例类，使用类的私有静态指针变量指向类的唯一实例，并用一个公有的静态方法来获取该实例。单例模式的作用就是保证在整个应用程序的生命周期中的任何一个时刻，单例类的实例都只存在一个（当然也可以不存在）。

单例模式通过类本身来管理其唯一实例，唯一的实例是类的一个普通对象，但设计这个类时，让它只能创建一个实例并提供对此实例的全局访问，具体可以参见下面的例2.33。

【例2.33】　单例模式使用举例。

#include<iostream>

using namespace std;

class CSingleton{

private:

CSingleton(){ // 构造函数是私有的

}

static CSingleton *m_pInstance;

public:

static CSingleton * GetInstance(){

if(m_pInstance == NULL) // 判断是否第一次调用

m_pInstance = new CSingleton();

return m_pInstance;

}

};

CSingleton * CSingleton::m_pInstance=NULL; // 初始化静态数据成员

int main(){

CSingleton *s1= CSingleton::GetInstance();

CSingleton *s2= CSingleton::GetInstance();

if(s1==s2){

cout<<"s1=s2"<<endl; // 程序的执行结果是输出了s1=s2

}

return 0;

}

程序的执行结果是：

s1=s2

例2.33中，用户访问实例的唯一方法只有GetInstance()成员函数。如果不通过这个函数，任何创建实例的尝试都将失败，因为类的构造函数是私有的。GetInstance()的返回值是当这个函数首次被访问时被创建的，所有GetInstance()之后的调用都返回相同实例的指针。

单例类CSingleton有以下特征：①有一个指向唯一实例的静态指针m_pInstance，并且是私有的；②有一个公有的函数，可以获取这个唯一的实例，并且在需要的时候创建该实例；③其构造函数是私有的，这样就不能从别处创建该类的实例。

2.4　本章小结

本章从对象的封装、继承、多态这三大特征来带领读者学习面向对象的C++。这3个特征分别解决了以下问题。

（1）封装：找到变化并且把它封装起来，就可以在不影响其他部分的前提下修改或扩展被封装的变化部分。封装解决了程序的可扩展性。

（2）继承：子类继承父类，可以继承父类的方法及属性，实现了多态以及代码的重用，解决了系统的重用性和扩展性，但是继承破坏了封装，因为其是对子类开放的，修改父类会导致所有子类的改变，因此继承一定程度上又破坏了系统的可扩展性，所以继承需要慎用。继承是在程序开发过程中重构得到的，而不是程序设计之初就使用继承，很多面向对象开发者滥用继承，结果可能造成后期的代码解决不了需求的变化。因此优先使用组合，而不是继承，是面向对象开发中一个重要的经验。

（3）多态：接口的多种不同的实现方式即为多态。接口是对行为的抽象，上面在“封装”中提到，找到变化部分并封装起来，但是封装起来后，怎么适应接下来的变化？这正是接口的作用，接口的主要目的是为不相关的类提供通用的处理服务，从而实现系统的可维护性、可扩展性。

因此，面向对象实现了人们追求的系统可维护性、可扩展性、可重用性。

第3章将学习STL，了解如何更高效地写程序，玩转C++。

第3章

常用STL的使用

3.1　STL是什么

当今时代是一个信息时代，科技的发展所带来的便利影响了人们生活中的每个细节，STL就是这个时代组件化大生产的产物。正如其他科技成果一样，C++程序员也应该努力使自己适应并充分利用这个“高科技成果”。

STL是一个标准模板库，是一个高效的C++程序库。接下来将以一个实例程序为例，逐步介绍STL的内容与功能。

假设需要从标准输入（一般是键盘）读入一些整型数据，再对它们排序，然后将结果输出到标准输出设备（一般是显示器屏幕），那程序可以如例3.1所示。

【例3.1】　用原始的方式将一些数据进行排序。

#include<iostream>

#include<stdlib.h>

using namespace std;

#define max_size 10

// 比较两个数的大小

// 如果比较函数返回大于0，qsort就认为a>b

// 如果比较函数返回等于0，qsort就认为a=b

// 如果比较函数返回小于0，qsort就认为a<b

int cmp(const void *a,const void *b){

return *(int *)a-*(int *)b;

}

int main(){

int arr[max_size];

int n=0;

// 从标准输入设备中读入整数，同时累计输入个数，直到输入的是非整型数据为止

for(;;n++){

cin>>arr[n];

}

qsort(arr,n,sizeof(int),cmp);

for(int i=0;i<n;i++){

cout<<arr[i]<<" ";

}

return 0;

}

以下是某次运行的结果：

输入：0 9 2 1 5

输出：0 1 2 5 9

例3.1中用了一个可以放10个整数的整型数组，来存放输入的数据，规定从标准输入设备中读入整数，同时累计输入个数，直到输入的是非整型数据为止；还用了C标准库的快速排序quit-sort函数来对输入的整数进行排序，并将排序结果输出到标准输出设备上。

然而，这个程序并不像看起来那么健壮（robust）。如果用户输入的数字数超过max_size所规定的上限，就会出现数组越界问题。为了弥补程序中的这一缺陷，必须采用下述方案中的一种。

（1）采用大容量的静态数据分配。

（2）限定输入的数据个数。

（3）采用动态内存分配。

第一种方案比较简单，所做的只是将max_size改大一点，比如1000或者10?000。但是，严格讲这并不能最终解决问题，隐患仍然存在。此外，分配一个大数组，通常是在浪费空间，因为大多数情况下，数组中的一部分空间并没有被利用。

再来看看第二种方案，通过在第一个for循环中加入一个限定条件，可以使问题得到解决。比如：for (int n = 0; cin >> num[n] && n < max_size; n ++);但是这个方案同样不甚理想，尽管不会使程序崩溃，但失去了灵活性，使用户无法输入更多的数。

看来只有选择第三种方案了，利用指针以及动态内存分配可以妥善解决上述问题，并且使程序具有良好的灵活性。这需要用到new、delete操作符，或者malloc()，realloc()和free()函数，但是为此，程序将牺牲其简洁性，使代码量陡增，代码的处理逻辑也不再像原先看起来那么清晰了。很难保证不会在处理这个问题的时候出错，很多程序的bug往往就是这样产生的。同时，stdlib.h库提供了quit-sort函数，避免了自己实现排序算法的麻烦。总之，需要考虑的问题越来越多。

接下来就将从STL的角度分析并解决这类问题。

3.2　string

字符串处理问题是C++语言编程中经常遇到的问题，熟练地掌握字符串处理的方法，可以增强对字符串的存储和其处理方法的理解，从而写出高效的C++程序。

在前面第1章讲到，字符串可以用字符指针char*、字符数组等来表示，先来回顾一下字符指针和字符数组的使用注意点。

比如下面这几行代码：

char str[12] = "Hello";

char *p = str;

*p = 'h'; // 改变第一个字母

再看这几行代码：

char *ptr = "Hello";

*ptr = 'h'; // 错误

第一个字符串时用数组开辟的，它是可以改变的变量。而第二个字符串则是一个常量，也就是不可改变的值。ptr只是指向它的指针而已，而不能改变指向的内容。这部分区别看两者的汇编语言即可明了：

char p[] = "Hello";的汇编代码如下：

004114B8 mov eax,dword ptr [string "Hello" (4166FCh)]

004114BD mov dword ptr [ebp-10h],eax

004114C0 mov cx,word ptr ds:[416700h]

004114C7 mov word ptr [ebp-0Ch],cx

char *ptr = "Hello";的汇编代码如下：

004114CB mov dword ptr [ebp-1Ch],offset string "Hello" (4166FCh)

可见用数组和用指针是完全不相同的。

要想通过指针来改变常量是错误，正确的写法应该是用const指针，如下所示：

const char *ptr = "Hello";

除了以上限制外，字符数组、字符指针的字符串会有要考虑内存释放是否足够、字符串长度等的问题，因此本章主要讲解string。它是一个字符串的类，它集成的操作函数足以完成大多数情况下的需要。可以用“=”进行赋值操作，“==”进行比较，“+”做串联，使用非常简单，甚至可直接把它看作C++的基本数据类型。

为了在程序中使用string类型，必须包含头文件<string>，如下所示：

#include<string>

string.h和cstring都不是string类的头文件，这两个头文件主要定义C语言风格字符串操作的一些方法，譬如strlen()、strcpy()等。string.h是C语言的头文件格式，而cstring是C++风格的头文件，但是和<string.h>是一样的，它的目的是为了和C语言兼容。

1.?string类的实现

实现string类是一道考验C++基础知识的好题，接下来先看这样的一道题目，了解string类的内部实现。

已知类string的原型代码如下所示，请编写类string的7个类。

class String{

public:

String(const char *str = NULL); // 普通构造函数

String(const String &other); // 拷贝构造函数

~ String(); // 析构函数

String & operator =(const String &other); // 赋值函数

String & operator +(const String &other); // 字符串连接

bool operator ==(const String &other); // 判断相等

int getLength(); // 返回长度

private:

char *m_data; // 私有变量保存字符串

};

从上述程序可以看到，string类其实是一个对字符串指针有一系列操作动作的类，也就是说，string类的底层是一个字符串指针。这一题的参考答案以及注意点如下所示。

（1）普通构造函数。

String::String(const char *str){

if(str==NULL){

m_data = new char[1];

*m_data = '\0';

// 对空字符串自动申请存放结束标志'\0'的加分点：对m_data加NULL 判断

}

else{

int length = strlen(str);

m_data = new char[length+1];

strcpy(m_data, str);

}

普通构造函数里需要注意的是，传入的是个char*类型的字符串。如果传入的str是个空的字符串，那这个string就也是一个空的字符串，直接用\0赋值。如果传入的str是非空字符串，私有变量m_data就需要预留length+1的长度，其中“+1”是用来放最后的'\0'的，因为strlen计算字符串长度时，没把'\0'算进去。

（2）String的析构函数。

String::~String(){

if(m_data){

delete[] m_data; // 或delete m_data;

m_data=0;

}

析构函数的主要功能主要是删除成员变量，需要先判断字符指针是否为空，如果不为空，再将其删除，并将其指向NULL。

（3）拷贝构造函数。

String::String(const String &other){ // 输入参数为const型

if(!other.m_data){ // 对m_data加NULL 判断

m_data=0;

}

m_data = new char[strlen(other.m_data)+1];

strcpy(m_data, other.m_data);

}

拷贝构造函数里需要注意的是，传入的参数是个常引用，这样可以不用新增一个栈变量和参数内容可以保持不变，不被修改。

（4）赋值函数。

String & String::operator =(const String &other){

// 输入参数为const型

if(this != &other){ // 检查是否自赋值

delete[] m_data; // 释放原有的内存资源

if(!other.m_data){ // 对m_data作NULL 判断

m_data=0;

}

else{

m_data=new char[strlen(other.m_data)+1];

strcpy(m_data, other.m_data);

}

return *this; // 返回本对象的引用

}

赋值函数里需要注意的是，如果传入的参数内容已与本身的内容一致，则不需要赋值。如果传入的参数内容与本身内容不一致，需要先清空本身的内容。

（5）字符串连接。

String & String::operator +(const String &other){

String newString;

if(!other.m_data){

newString=*this;

}

else if(!m_data){

newString=other;

}

else{

newString.m_data=new char[strlen(m_data)+strlen(other.m_data)+1];

strcpy(newString.m_data,m_data);

strcat(newString.m_data,other.m_data);

}

return newString;

}

字符串连接函数里需要注意的分3种情况：传入的参数内容为空、本身内容为空或两者内容都不为空。

（6）判断相等。

bool String::operator= =(const String &other){

if(strlen(m_data)!=strlen(other.m_data)){

return false;

}

else{

return strcmp(m_data,other.m_data)?false:true;

}

判断相等函数，返回值只有true和false，先判断长度是否一致，再判断内容是否一致。

（7）返回长度。

int String::getLength(){

return strlen(m_data);

}

返回长度函数，只需用strlen直接计算char*的长度即可。

2.?string声明方式

字符串变量的声明形式如下：

string Str;

这样就声明了一个字符串变量，但既然是一个类，就有构造函数和析构函数。上面的声明没有传入参数，所以就直接使用了string的默认的构造函数，这个函数所做的就是把Str初始化为一个空字符串。string类的构造函数和析构函数如下所示：

string s; // 生成一个空字符串s

string s(string str) // 拷贝构造函数生成str的复制品

string s(string str,int stridx) // 将字符串str内“始于位置stridx”的部分当作

// 字符串的初值

string s(char *str,int stridx,int strlen) // 将字符串str内“始于stridx且长度顶多strlen”

// 的部分作为字符串的初值

string s(char *cstr) // 将C字符串作为s的初值

string s(char *chars,int chars_len) // 将C字符串前chars_len个字符作为字符串s的

// 初值

string s(int num,char c) // 生成一个字符串，包含num个c字符

string s(char *beg,char *end) // 以区间beg;end(不包含end)内的字符作为字符

// 串s的初值

s.~string() // 销毁s字符，释放内存

string类的声明如例3.2所示。

【例3.2】　string的声明。

#include<iostream>

#include<string>

using namespace std;

int main(){

string str1="Spend all your time waiting.";

string str2="For that second chance.";

string str3(str1,6); // "all your time waiting."

string str4(str1,6,3); // "all"

char ch_music[]={"Sarah McLachlan"};

string str5=ch_music;

string str6(ch_music);

string str7(ch_music,5); // "Sarah"

string str8(4,'a'); // aaaa

string str9(ch_music+6,ch_music+14); // " McLachlan"

cout<<"str1:"<<str1<<endl;

cout<<"str2:"<<str2<<endl;

cout<<"str3:"<<str3<<endl;

cout<<"str4:"<<str4<<endl;

cout<<"str5:"<<str5<<endl;

cout<<"str6:"<<str6<<endl;

cout<<"str7:"<<str7<<endl;

cout<<"str8:"<<str8<<endl;

cout<<"str9:"<<str9<<endl;

return 0;

}

程序的执行结果是：

str1:Spend all your time waiting.

str2:For that second chance.

str3:all your time waiting.

str4:all

str5:Sarah McLachlan

str6:Sarah McLachlan

str7:Sarah

str8:aaaa

str9:McLachla

例3.2中展示了声明一个string字符串的各种方式。

3.?C++字符串和C字符串的转换

C++提供的由C++字符串转换成对应的C字符串的方法是使用data()、c_str()和copy()来实现。其中，data()以字符数组的形式返回字符串内容，但并不添加'\0'；c_str()返回一个以'\0'结尾的字符数组；而copy()则把字符串的内容复制或写入既有的c_string或字符数组内。需要注意的是，C++字符串并不以'\0'结尾。

c_str()语句可以生成一个const char *指针，并指向空字符的数组。这个数组的数据是临时的，当有一个改变这些数据的成员函数被调用后，其中的数据就会失效。因此要么现用现转换，要么把它的数据复制到用户自己可以管理的内存中后再转换。

【例3.3】　c_str()使用方法举例。

#include<iostream>

#include<string>

using namespace std;

int main(){

string str="Hello world.";

const char * cstr=str.c_str();

cout<<cstr<<endl;

str="Abcd.";

cout<<cstr<<endl;

return 0;

}

程序的执行结果是：

Hello world.

Abcd.

如例3.3所示，改变了str的内容，cstr的内容也会随着改变。所以上面如果继续使用C指针的话，导致的错误将是不可想象的。既然C指针指向的内容容易失效，就可以考虑把数据复制出来解决问题。

【例3.4】　将c_str()里的内容复制出来以保持有效性。

#include<iostream>

#include<string>

#include<string.h>

using namespace std;

int main(){

char * cstr=new char[20];

string str="Hello world.";

strncpy(cstr,str.c_str(),str.size());

cout<<cstr<<endl;

str="Abcd.";

cout<<cstr<<endl;

return 0;

}

程序的执行结果：

Hello world.

例3.4中用strcpy函数将str.c_str()的内容复制到cstr里了，这样就能保证cstr里的内容不随着str的内容改变而改变了。

copy(p,n,size_type _Off = 0)这句表明从string类型对象中至多复制n个字符到字符指针p指向的空间中，并且默认从首字符开始，也可以指定开始的位置（从0开始计数），返回真正从对象中复制的字符。不过用户要确保p指向的空间足够来保存n个字符。

【例3.5】　string.copy用法的详细举例。

#include<iostream>

#include<string>

using namespace std;

int main (){

size_t length;

char buffer[8];

string str("Test string......");

cout<<"str:"<<str<<endl;

length=str.copy(buffer,7,5);

buffer[length]='\0';

cout<<"str.copy(buffer,7,5),buffer contains: "<<buffer<<endl;

length=str.copy(buffer,str.size(),5);

buffer[length]='\0';

cout<<"str.copy(buffer,str.size(),5),buffer contains:"<<buffer<<endl;

length=str.copy(buffer,7,0);

buffer[length]='\0';

cout<< "str.copy(buffer,7,0),buffer contains:"<<buffer<<endl;

length=str.copy(buffer,7); // 缺省参数pos，默认pos=0;

buffer[length]='\0';

cout<<"str.copy(buffer,7),buffer contains:"<<buffer<<endl;

length=str.copy(buffer,string::npos,5);

buffer[length]='\0';

cout<<"string::npos:"<<(int)(string::npos)<<endl;

cout<<"buffer[string::npos]:"<<buffer[string::npos]<<endl;

cout<<"buffer[length-1]:"<<buffer[length-1]<<endl;

cout<<"str.copy(buffer,string::npos,5),buffer contains:"<<buffer<<endl;

length=str.copy(buffer,string::npos);

buffer[length]='\0';

cout<<"str.copy(buffer,string::npos),buffer contains:"<<buffer<<endl;

cout<<"buffer[string::npos]:"<<buffer[string::npos]<<endl;

cout<<"buffer[length-1]:"<<buffer[length-1]<<endl;

return 0;

}

程序的执行结果是：

str:Test string......

str.copy(buffer,7,5),buffer contains: string.

str.copy(buffer,str.size(),5),buffer contains:string......

str.copy(buffer,7,0),buffer contains:Test st

str.copy(buffer,7),buffer contains:Test st

string::npos:-1

buffer[string::npos]:

buffer[length-1]:.

str.copy(buffer,string::npos,5),buffer contains:string......

str.copy(buffer,string::npos),buffer contains:Test string......

buffer[string::npos]:

buffer[length-1]:.

例3.5中展示了通过不同的方法用string的copy方法进行字符串的复制，常见的api的参数一般是把起始点信息放在前面，长度信息放在后面，如string的构造函数string s(char *str,int stridx,int strlen)；而copy方法却是把长度放在起始点前面，这个是需要小心使用的。另外，copy函数的第二个参数，除了可以是长度，也可以是一个位置，如string::npos。

string::npos是一个机器最大的正整数，不同机器不一样，如64位机器是184467440

73709551615，而32位机器则是4294967295，类型是std::container_type::size_type。可以将其强制转换成int，就是-1，这样就不会存在移植的问题。一般用npos表示string的结束位置。

copy函数的第三个参数不填时则默认为0，即从第一个字符开始。

综上，可以使用string的c_str()、data()、copy(p,n)，从一个string类型得到一个C类型的字符数组。

4.?string和int类型的转换

（1）int转string的方法。

这里需要用到snprintf()，函数原型为：

int snprintf(char *str, size_t size, const char *format, ...)

它的功能主要是将可变个参数(...)按照format格式化成字符串，然后将其复制到str中，具体如下所述。

1）如果格式化后的字符串长度小于size，则将此字符串全部复制到str中，并给其后添加一个字符串结束符('\0')。

2）如果格式化后的字符串长度不小于size，则只将其中的(size-1)个字符复制到str中，并给其后添加一个字符串结束符('\0')，返回值为欲写入的字符串长度。

3）函数的返回值是若成功，则返回欲写入的字符串长度，若出错则返回负值。

4）如果原始参数为“…”，那么这是个可变参数。

【例3.6】　snprintf的使用举例。

#include<stdio.h>

int main (){

char a[20];

int i = snprintf(a, 9, "%012d", 12345);

printf("i = %d, a = %s", i, a);

return 0;

}

程序的执行结果是：

i = 12, a = 00000001

例3.6中，%012d的格式是指使输出的int型的数值以12位的固定位宽输出，如果不足12位，则在前面补0；如果超过12位，则按实际位数输出。如果输出的数值不是int型，则进行强制类型转换为int，之后按前面的格式输出。那就是先得到了000000012345，再取前面（9-1）位，即8位，则是00000001。

与此类似的，将int转换为string，代码通常可以这么写：

static inline std::string i64tostr(long long a){

char buf[32];

snprintf(buf, sizeof(buf), "%lld", a);

return std::string(buf);

}

（2）string转int的方法。

这里需要用到strtol，strtoll，strtoul或strtoull函数，它们的函数原型分别如下所示：

long int strtol(const char *nptr, char **endptr, int base);

long long int strtoll(const char *nptr, char **endptr, int base);

unsigned long int strtoul(const char *nptr, char **endptr, int base);

unsigned long long int strtoull(const char *nptr, char **endptr, int base);

它们的功能是将参数nptr字符串根据参数base来转换成有符号的整型数、有符号的长整型数，无符号的整型数、无符号的长整型数。参数base范围从2～36，或0。参数base代表采用的进制方式，如base值为10则采用10进制；若base值为16则采用16进制数等；当base值为0时会根据情况选择用哪种进制：如果第一个字符是0，就判断第二字符如果是x则用16进制，否则用8进制，第一个字符不是0，则用10进制。一开始strtoul()会扫描参数nptr字符串，跳过前面的空格字符串，直到遇上数字或正负符号才开始做转换，再遇到非数字或字符串结束时(' ')结束转换，并将结果返回。若参数endptr不为NULL，则会将遇到不合条件而终止的nptr中的字符指针由endptr返回。

strtol使用如例3.7所示。

【例3.7】　strtol的使用举例。

#include<iostream>

#include<stdlib.h>

#include<string>

using namespace std;

int main(){

char *endptr;

char nptr[]="123abc";

int ret = strtol(nptr, &endptr, 10 );

cout<<"ret:"<<ret<<endl;

cout<<"endptr:"<<endptr<<endl;

char *endptr2;

char nptr2[]=" \n\t abc";

ret = strtol(nptr2, &endptr2, 10 );

cout<<"ret:"<<ret<<endl;

cout<<"endptr2:"<<endptr2<<endl;

char *endptr8;

char nptr8[]="0123";

ret = strtol(nptr8, &endptr8,0);

cout<<"ret:"<<ret<<endl;

cout<<"endptr8:"<<endptr8<<endl;

char *endptr16;

char nptr16[]="0x123";

ret = strtol(nptr16, &endptr16,0);

cout<<"ret:"<<ret<<endl;

cout<<"endptr16:"<<endptr16<<endl;

return 0;

}

程序的执行结果是：

ret:123

endptr:abc

ret:0

endptr2:

abc

ret:83

endptr8:

ret:291

endptr16:

例3.7中主要是使用strtol函数对不同的字符串取出整数。

char nptr[]="123abc";

int ret = strtol(nptr, &endptr, 10 );

十进制里没有“数字”a，所以扫描到a就结束，因此ret值是123，即endptr是abc。

char *endptr2;

char nptr2[]=" \n\t abc";

ret = strtol(nptr2, &endptr2, 10 );

由于函数会忽略nptr前面的空格，所以从字符a开始扫描，但是遇见的“第一个”即是不合法字符，所以函数结束，此时ret=0; endptr = nptr;

char *endptr8;

char nptr8[]="0123";

ret = strtol(nptr8, &endptr8,0);

char *endptr16;

char nptr16[]="0x123";

ret = strtol(nptr16, &endptr16,0);

当第三个参数为0时，则分以下3种情况。

1）如果nptr以0x开头，则把nptr当成16进制处理。

2）如果npstr以0开头，则把nptr当成8进制处理。

3）否则，把nptr当成10进制。

nptr8是以0开头的，所以将nptr8当成8进制处理，再将8进制的0123转换为10进制的，得到了1*8^2+2*8+3=83。nptr16是以0x开头的，将nptr16当成16进制处理，再将16进制的0x123转换为10进制的，得到了1*16^2+2*16+3=291。

因此，将字符串转换为10进制的数字，可以这么写：

static inline int64_t strtoint(const std::string& s){

return strtoll(s.c_str(), 0, 10);

}

5.?string的其他常用成员函数

string的其他常用成员函数有以下几个：

int capacity()const; // 返回当前容量(即string中不必增加内存即可存放的元素个数)

int max_size()const; // 返回string对象中可存放的最大字符串的长度

int size()const; // 返回当前字符串的大小

int length()const; // 返回当前字符串的长度

bool empty()const; // 当前字符串是否为空

void resize(int len,char c); // 把字符串当前大小置为len，并用字符c填充不足的部分

3.3　vector

3.3.1　 vector是什么

vector是线性容器，它的元素严格按照线性序列排序，和动态数组很相似。和数组类似的是，它的元素存储在一块连续的存储空间中，这也意味着不仅可以使用迭代器（iterator）访问元素，还可以使用指针的偏移方式访问。和常规数组不一样的是，vector能够自动存储元素，可以自动增长或缩小存储空间。

vector的优点如下所述。

（1）可以使用下标访问个别的元素。

（2）迭代器可以按照不同的方式遍历容器。

（3）可以在容器的末尾增加或删除元素。

和数组相比，虽然容器在自动处理容量的大小时会消耗更多的内存，但是容器能提供和数组一样的性能，而且能很好地调整存储空间大小。

和其他标准的顺序容器相比，vector能更有效访问容器内的元素和在末尾添加和删除元素；而在其他位置添加和删除元素，vector则不及其他顺序容器，在迭代器和引用也不比lists支持的好。

容器的大小和容器的容量是有区别的，大小是指元素的个数，容量是分配的内存大小，容量一般不小于容器的大小。vector::size()返回容器的大小，vector::capacity()返回容量值，容量多于容器大小的部分用于以防容器大小的增加使用。每次重新分配内存都会很影响程序的性能，所以一般分配的容量都大于容器的大小，若要自己指定分配的容量的大小，则可以使用vector::reserve()，但是规定的值要大于size()值。

使用vector时需要包含的头文件#include<vector>。

3.3.2　vector的查增删

1.?vector的初始化和遍历

vector的初始化方法如表3-1所示。

表3-1　vector的各种初始化方法

vector<T> v1 v1是一个空vector，它潜在的元素是T类型的，执行默认初始化

vector<T> v2(v1) v2中包含有v1所有元素的副本

vector<T> v2 = v1 等价于v2(v1)，v2中包含有v1所有元素的副本

vector<T> v3(n, val) v3包含了n个重复的元素，每个元素的值都是val

vector<T> v4(n) v4包含了n个重复地执行了值初始化的对象

vector<T> v5{a,b,c...} v5包含了初始值个数的元素，每个元素被赋予相应的初始值

vector<T> v5={a,b,c...} 等价于v5{a,b,c...}

vector的遍历有for(int i=0;i<a.size();++i)、for (iter=ivector.begin();iter!=ivector.end();iter++)、for_each这几种方式。

【例3.8】　vector的初始化和遍历。

#include <vector>

#include <iostream>

using namespace std;

int main(){

int a[7]={1,2,3,4,5,6,7};

vector<int> ivector(a,a+7);

/*vector的赋值并不可以像数组一样用花括号方便地完成赋值，这里借用了数组来初始化这个vector

初始化方式vector<elementType> intvec(begin,end);这样可以用起来看上去还是比较习惯的。*/

vector<int>::iterator iter;

for (iter=ivector.begin();iter!=ivector.end();iter++){

cout<<*iter<<" ";

}

cout<<endl;

ivector[5]=1;

/*单个vector的赋值，这个方式看上去还是和数组一样的也可以这么写ivector.at(5)=1;但是

就是不习惯*/

cout<<ivector[5]<<endl<<ivector.size()<<endl;

for (iter=ivector.begin();iter!=ivector.end();iter++){

cout<<*iter<<" ";

}

cout<<endl;

for(int i=0;i<5;i++){

cout<<ivector[i]<<" ";

}

cout<<endl;

return 0;

}

程序的执行结果是：

1 2 3 4 5 6 7

1 2 3 4 5 1 7

1 2 3 4 5

例3.8中展示了for(int i=0;i<a.size();++i)、for (iter=ivector.begin();iter!=ivector.end();iter++)的遍历方式，vector中也可以直接用ivector[i]的方式访问第i个元素。

【例3.9】　for_each的遍历举例。

#include <vector>

#include <algorithm>

#include <iostream>

using namespace std;

void print(int n)

{

cout<<n<<" ";

}

int main(){

int a[7]={1,2,3,4,5,6,7};

vector<int> ivector(a,a+7);

vector<int>::iterator iter;

for_each(ivector.begin(),ivector.end(),print);// 用for_each进行遍历

cout<<endl;

ivector[5]=1;

cout<<ivector[5]<<endl<<ivector.size()<<endl;

for_each(ivector.begin(),ivector.end(),print);// 用for_each进行遍历

return 0;

}

程序的执行结果为：

1 2 3 4 5 6 7

1 2 3 4 5 1 7

例3.9中展示了如何使用for_each遍历vector中的元素。

vector是个模板类，可以存放任何类型的对象。在vector中存放结构体时，可以按照自定义的排序方式排序。

【例3.10】　vector中存放结构体时的排序。

#include<algorithm>

#include<vector>

#include<iostream>

using namespace std;

typedef struct rect{

int id;

int length;

int width;

bool operator< (const rect &a) const{

if(id!=a.id)

return id<a.id;

else{

if(length!=a.length)

return length<a.length;

else

return width<a.width;

}

}Rect;

int main(){

vector<Rect> vec;

Rect rect;

rect.id=2;

rect.length=3;

rect.width=4;

vec.push_back(rect);

rect.id=1;

rect.length=2;

rect.width=3;

vec.push_back(rect);

vector<Rect>::iterator it=vec.begin();

cout<<(*it).id<<' '<<(*it).length<<' '<<(*it).width<<endl;

sort(vec.begin(),vec.end());

cout<<(*it).id<<' '<<(*it).length<<' '<<(*it).width<<endl;

return 0;

}

程序的执行结果是：

2 3 4

1 2 3

例3.10中，vec中存放的是结构体Rect。vec未进行排序前，将会按照push_back的时间顺序排序，并不会自动排序。排序后，可以按照结构体中对rect的重载方式进行排序：按照id、length、width升序排序，然后用<algorithm>中的sort函数排序。

除了重载结构体里的rect，也可以在结构体外定义一个函数来进行比较。

【例3.11】　结构体外定义比较函数。

#include<algorithm>

#include<vector>

#include<iostream>

using namespace std;

typedef struct rect{

int id;

int length;

int width;

}Rect;

int cmp(Rect a,Rect b){

if(a.id!=b.id)

return a.id<b.id;

else{

if(a.length!=b.length)

return a.length<b.length;

else

return a.width<b.width;

}

int main(){

vector<Rect> vec;

Rect rect;

rect.id=2;

rect.length=3;

rect.width=4;

vec.push_back(rect);

rect.id=1;

rect.length=2;

rect.width=3;

vec.push_back(rect);

vector<Rect>::iterator it=vec.begin();

cout<<(*it).id<<' '<<(*it).length<<' '<<(*it).width<<endl;

sort(vec.begin(),vec.end(),cmp);

cout<<(*it).id<<' '<<(*it).length<<' '<<(*it).width<<endl;

return 0;

}

程序的执行结果是：

2 3 4

1 2 3

例3.11与例3.10不同的地方是，例3.11中并没有对结构体进行重载，而是在结构体外定义了一个比较函数；另外sort的调用方式也不相同，例3.11中加了个比较函数作为第3个参数。二者均可以实现对vec的排序。

2.?vector的查找

在vector中查找一个元素可以如例3.12所示。

【例3.12】　在vector中查找元素。

#include<algorithm>

#include<vector>

#include<iostream>

using namespace std;

int main(){

vector<int> vec;

vec.push_back(1);

vec.push_back(2);

vec.push_back(3);

vec.push_back(4);

vec.push_back(5);

vector<int>::iterator iter=find(vec.begin(),vec.end(),3);

if ( iter==vec.end())

cout << "Not found" << endl;

else

cout << "Found" << endl;

return 0;

}

程序的执行结果是：

Found

例3.12中，使用了f?ind函数在vector中进行查找。注意f?ind函数不属于vector的成员，而存在于算法中，所以应加上头文件#include <algorithm>。

3.?vector的删除

vector中的删除，可以有erase或pop_back函数。erase可以删除指定元素或指定位置的元素，而pop_back只能去掉数组的最后一个数据。

erase的函数原型有以下两种形式：

iterator erase(iterator position)。

iterator erase(iterator first, iterator last)。

假设有这样的程序：

vector<int> vec;

vec.push_back(1);

vec.push_back(2);

vec.push_back(3);

vec.push_back(4);

vec.push_back(5);

for(vector<int>::iterator iter=veci.begin(); iter!=veci.end(); iter++){

if( *iter == 3)

veci.erase(iter);

}

乍一看这段代码很正常，其实这里面隐藏着一个很严重的错误：当veci.erase(iter)语句执行了之后，iter就变成了一个野指针，对一个野指针进行iter++操作是肯定会出错的。

查看MSDN，对于erase的返回值是这样描述的：An iterator that designates the f?irst element remaining beyond any elements removed, or a pointer to the end of the vector if no such element exists，于是改代码：

for(vector<int>::iterator iter=vec.begin(); iter!=vec.end(); iter++){

if( *iter == 3)

iter = vec.erase(iter);

}

这段代码也是错误的：①无法删除两个连续的3；②当数字3位于vector最后位置的时候，也会出错（在vec.end()上执行++操作）。正确的代码应如例3.13所示。

【例3.13】　使用erase删除vector中某个元素。

#include<algorithm>

#include<vector>

#include<iostream>

using namespace std;

int main(){

vector<int> vec;

vec.push_back(1);

vec.push_back(2);

vec.push_back(3);

vec.push_back(4);

vec.push_back(5);

vector<int>::iterator iter=vec.begin();

for(;iter!=vec.end();){

if(*iter==3){

iter=vec.erase(iter);

}else{

++iter;

}

for(iter=vec.begin();iter!=vec.end();iter++){

cout<<*iter<<" ";

}

return 0;

}

程序的执行结果是：

1 2 4 5

例3.13中，for语句条件里面删除元素时，返回值指向已删除元素的下一个位置，不是删除元素时则直接进行++操作。

使用vec.erase(vec.begin()+i,vec.end()+j)语句则是删除区间[i,j-1]间的元素。

而pop_back只能去掉数组的最后一个数据。

【例3.14】　vector的pop_back函数使用举例。

#include<algorithm>

#include<vector>

#include<iostream>

using namespace std;

int main(){

vector<int> vec;

for(int i=0;i<10;i++)

vec.push_back(i);

vector<int>::iterator iter=vec.begin();

for(iter=vec.begin();iter!=vec.end();iter++){

cout<<*iter<<" ";

}

cout<<endl;

vec.pop_back();

for(iter=vec.begin();iter!=vec.end();iter++){

cout<<*iter<<" ";

}

cout<<endl;

return 0;

}

程序的执行结果是：

0 1 2 3 4 5 6 7 8 9

0 1 2 3 4 5 6 7 8

例3.14中定义了一个存放整型数的vector，里面存放了0～9。用pop_back函数，则把最晚进入vector的9删除。

4.?vector的增加

vector中的增加，可以有insert和push_back。insert是插入元素到某个位置中，push_back是在最后添加一个元素。

insert的函数原型有以下3种形式：

iterator insert( iterator loc, const TYPE &val );

// 在指定位置loc前插入值为val的元素,返回指向这个元素的迭代器

void insert( iterator loc, size_type num, const TYPE &val );

// 在指定位置loc前插入num个值为val的元素

void insert( iterator loc, input_iterator start, input_iterator end );

// 在指定位置loc前插入区间[start, end)的所有元素

【例3.15】　vector的查增删用法举例。

#include<algorithm>

#include<vector>

#include<iostream>

using namespace std;

void print( vector<int>v ){

vector<int>::iterator iter=v.begin();

for(;iter!=v.end();iter++)

cout<<*iter<<" ";

cout<<endl;

}

int main(){

vector<int> v; // 现在容器中有0个元素

int values[] = {1,3,5,7};

v.insert(v.end(), values+1, values+3); // 现在容器中有2个元素分别为:3,5

print(v);

v.push_back(9); // 现在容器中有3个元素分别为:3,5,9

print(v);

v.erase(v.begin()+1); // 现在容器中有2个元素分别为:3,9

print(v);

v.insert(v.begin()+1, 4); // 现在容器中有3个元素分别为:3,4,9

print(v);

v.insert(v.end()-1, 4, 6); // 现在容器中有7个元素分别为:3,4,6,6,6,6,9

print(v);

v.erase(v.begin()+1, v.begin()+3); // 现在容器中有5个元素分别为:3,6,6,6,9

print(v);

v.pop_back(); // 现在容器中有4个元素分别为:3,6,6,6

print(v);

v.clear(); // 现在容器中有0个元素

print(v);

if (true == v.empty()) // 如果容器为空则输出“null”

{

std::cout<<"null"<<std::endl;

}

return 0;

}

例3.15的程序的执行结果如图3-1所示。

例3.15中的语句：

v.insert(v.end(), values+1, values+3);

就是将数组第2个元素和第3个元素的值插入到v.end()位置中，因为此时v还是空的，所以也就是往空vector里插入了两个元素。注意，这里只插入了两个元素，而没有插入3个元素。

v.erase(v.begin()+1);

v.begin()是指第1个元素，那v.begin()+1就是指第2个元素，即这里是删除第2个元素。

v.insert(v.end()-1, 4, 6);

v.end()是指最后一个元素的下一个位置，v.end()-1就是倒数第2个元素的前面一个位置，插入4个6，因此结果是3 4 6 6 6 6 9。

程序中v.clear()表示将v清空；v.empty()表示判断vector是否为空，如果为空，则返回true。

3.3.3　 vector的内存管理与效率

1.?使用reserve()函数提前设定容量大小

关于STL容器，最令人称赞的特性之一就是只要不超过它们的最大值，就可以自动增长到足以容纳用户放进去的数据的大小。（这个最大容量值，只要调用名叫max_size的成员函数就可以获得）对于vector和string，如果需要更多空间，就会以类似realloc的思想来增长大小。vector容器支持随机访问，因此为了提高效率，它内部是使用动态数组的方式实现的。在通过reserve()函数来申请特定大小的内存空间时候总是按指数边界来增大其内部缓冲区。当进行insert或push_back等增加元素的操作时，如果此时动态数组的内存不够用，就要动态的重新分配当前大小的1.5～2倍的新内存区，再把原数组的内容复制过去。所以，在一般情况下，其访问速度同一般数组相比，只有在重新分配发生时，其性能才会下降。正如例3.15中的代码一样，进行pop_back操作时，capacity并不会因为vector容器里的元素减少而有所下降，还会维持操作之前的大小。对于vector容器来说，如果有大量的数据需要进行push_back，应当使用reserve()函数提前设定其容量大小，否则会出现许多次容量扩充操作，导致效率低下。

reserve成员函数允许开发者最小化必须进行的重新分配的次数，因而可以避免真分配的开销和迭代器、指针、引用失效。但在解释reserve为什么可以那么做之前，需要先简要介绍有时候令人困惑的4个相关成员函数，如下所述。在标准容器中，只有vector和string提供了所有这些函数。

（1）size()可以获得容器中有多少元素，但不能获得容器为它容纳的元素分配的内存大小。

（2）capacity()可以获得容器在它已经分配的内存中可以容纳多少元素。那是容器在那块内存中总共可以容纳多少元素，而不是还可以容纳多少元素。如果想知道一个vector或string中有多少没有被占用的内存，则必须从capacity()中减去size()。如果size和capacity返回同样的值，容器中就没有剩余空间了，而下一次插入（通过insert或push_back等）会引发上面的重新分配步骤。

（3）resize(Container::size_type n)用来强制把容器改为容纳n个元素。调用resize函数之后，size函数将会返回n。如果n小于当前大小，容器尾部的元素会被销毁。如果n大于当前大小，新默认构造的元素会添加到容器尾部。如果n大于当前容量，在元素加入之前会进行重新分配。

（4）reserve(Container::size_type n)强制容器把它的容量改为不小于n，提供的n不小于当前所需的大小。因为容量需要增加，这一般会强迫进行一次重新分配。如果n小于当前容量，vector会忽略它，则这个调用什么都不做，string可能把它的容量减少为size()和n中大的数，但string的大小没有改变。

综上所述，只要有元素需要插入而且容器的容量不足时就会发生重新分配（包括它们维护的原始内存分配和回收，对象的拷贝和析构和迭代器、指针和引用的失效）。所以，避免重新分配的关键是使用reserve尽快把容器的容量设置为足够大，最好在容器被构造之后立刻进行。

例如，假定想建立一个容纳1～1000值的vector<int>，若不使用reserve，则可以像这样来做：

vector<int> v;

for (int i = 1; i <= 1000; ++i) v.push_back(i);

在大多数STL实现中，这段代码在循环过程中将会导致2～10次重新分配。（10这个数没什么奇怪的。记住vector在重新分配发生时一般把容量翻倍，而1000约等于210。）

把代码改为使用reserve，如下所示：

vector<int> v;

v.reserve(1000);

for (int i = 1; i <= 1000; ++i) v.push_back(i);

则这在循环中不会发生重新分配。

由大小和容量之间的关系可以预言什么时候插入将引起vector或string执行重新分配，而且，可以预言什么时候插入会使指向容器中的迭代器、指针和引用失效。例如，给出这段代码：

string s;

...

if (s.size() < s.capacity()) {

s.push_back('x');

}

push_back的调用不会使指向这个string中的迭代器、指针或引用失效，因为string的容量保证大于它的大小；如果不是执行push_back，代码在string的任意位置进行一个insert，仍然可以保证在插入期间没有发生重新分配，但是，与伴随string插入时迭代器失效的一般规则一致，所有从插入位置到string结尾的迭代器、指针、引用将失效。

通常有两种情况使用reserve来避免不必要的重新分配。第一种可用的情况是当知道有多少元素将最后出现在容器中时，就像上面的vector代码，就可以提前reserve适当数量的空间；第二种情况是保留可能需要的最大的空间，然后添加完全部数据后，再修整掉任何多余的容量。

2.?使用“交换技巧”来修整vector过剩空间/内存

有一种方法来把它从曾经最大的容量减少到它现在需要的容量，这样的方法常常被称为“收缩到合适”（shrink to f?it）。该方法只需一条语句：vector<int>(ivec).swap(ivec)。

表达式vector<int>(ivec)表示建立一个临时vector，它是ivec的一份拷贝。但是，vector的拷贝构造函数只分配拷贝的元素需要的内存，所以这个临时vector没有多余的容量。然后临时vector和ivec交换数据完成，但ivec只有临时变量的修整过的容量，而这个临时变量则持有了曾经在ivec中的没用到的过剩容量。在这个语句结尾处，临时vector被销毁，以释放以前ivec使用的内存，收缩到合适的大小。

3.?用swap方法强行释放vector所占内存

template < class T> void ClearVector( vector<T>& v )

{

vector<T>vtTemp;

vtTemp.swap( v );

}

vector<int> v ;

nums.push_back(1);

nums.push_back(3);

nums.push_back(2);

nums.push_back(4);

vector<int>().swap(v);

/* 或者v.swap(vector<int>()); */

/*或者{ std::vector<int> tmp = v; v.swap(tmp); }; // 加大括号{ }是让tmp退出{ }

// 时自动析构*/

4.?Vector 内存管理成员函数的行为测试

【例3.16】　vector内存管理成员函数的行为测试。

#include <iostream>

#include <vector>

using namespace std;

int main(){

vector<int> iVec;