2010年面向对象课程设计实习指导书v1.1

更新时间：2023-03-09 05:46:02 阅读量：综合文库文档下载

说明：文章内容仅供预览，部分内容可能不全。下载后的文档，内容与下面显示的完全一致。下载之前请确认下面内容是否您想要的，是否完整无缺。

2010世界杯推荐度：
相关推荐

中国地质大学（武汉）信息工程学院软件工程系

面向对象课程设计

实习指导书

使用班级：111091~2

指导老师：叶亚琴杨林

2010-5-13

面向对象课程设计指导书

一、课程设计目的...................................................................................................................... 3 二、课程设计要求...................................................................................................................... 3 三、课程设计题目...................................................................................................................... 3

预备任务............................................................................................................................. 3 实习任务1 .......................................................................................................................... 7 实习任务2 .......................................................................................................................... 9 实习任务3 ........................................................................................................................ 10 实习任务4 ........................................................................................................................ 11 实习任务5 ........................................................................................................................ 12 实习任务6 ........................................................................................................................ 13 四、成绩评定及评分标准 ......................................................................................................... 14 附件一、C++编码规范 ............................................................................................................. 15

1、文件组织 ..................................................................................................................... 15

2、命名规则 ..................................................................................................................... 17 3、注释 ............................................................................................................................ 21 4、程序的版式 .................................................................................................................. 24 5、可移植性 ..................................................................................................................... 37 6、提高程序的效率 ........................................................................................................... 38 附件二、课程设计报告格式...................................................................................................... 39

- 2 - 2

面向对象课程设计指导书

一、课程设计目的

程序设计是一门实践性非常强的教学环节，学生在《面向对象的程序设计》课程结束后，由于课内实习时间的不足，很多内容还来不及消化，特别是多态的概念。本课程设计的目的就是要通过时间相对集中的强化训练，使学生对所学理论知识进行一次综合性复习，进一步提高程序设计的能力。本课程设计的重点在于培养学生程序设计和软件开发有关的综合能力，具体包括：

1、培养学生对实际问题的分析能力；

2、培养学生独立编程、开发软件的动手能力； 3、培养学生开放思维的创新能力； 4、培养学生熟练掌握VC++调试技能； 5、培养学生规范的编程习惯；

6、培养学生撰写课程设计报告的能力。

二、课程设计要求

为了能更好地达到课程设计的目的，要求学生：

1、每次上机前充分做好准备工作，查阅资料，预习相关内容，对课程设计内容进行方案的预设计，编制出源程序代码。

2、充分利用上机时间完成源程序代码的输入、调试及优化。

3、程序代码的编制应按照C++编码规范的要求进行，具体可参考指导书中【附件一】“C++编码规范”。并将规范应用到你的实际编程中去，形成良好的习惯。

4、课程设计结束后，按照指导书中【附件二】“课程设计报告格式”的要求撰写出课程设计报告（要求用A4纸打印，报告格式的电子文档由指导教师提供）。预备任务~任务1不需要撰写报告，但要检查程序；实习任务2~6要填写报告。

5、按题目要求独立完成课程设计，不旷课、不迟到、不早退、遵守机房规定、爱护机房设备。

三、课程设计题目

预备任务

1. 实习说明：

该任务专门针对MFC基本框架还不熟悉的同学，若你能较快完成，请直接从实习任务1开始。

2. 实习内容：

在Visual Studio2005中创建MFC基本框架，添加菜单，添加菜单处理函数，增加自己的类，复习调试技术。

- 3 - 3

面向对象课程设计指导书

3. 实习目标（实习结束时请在达到的目标前打勾√）：

（1）初步掌握新建（new）基本MFC项目的方法；

（2）可以添加自定义菜单；

（3）可以添加菜单的消息处理函数；（4）能够使用AfxMessageBox函数；（5）能够添加自定义的类文件；

（6）能够掌握防止头文件重复包含的方法；（7）能够编写基本的类；

（8）初步熟悉MFC单文档框架工程的文件组成；（9）复习了调试技术。 4. 上机指南：

（1）启动Visual Studio2005；

（2）创建一个新的项目（包括解决方案），可命名为try1

（2.1）点击“File（文件）”?“New（新建）”?“Project（项目）”；

（2.2）在“Project types（项目类型）”中选“Win32”；（2.3）在“Templates（模版）”中选“MFC应用程序”；（2.4）在“Name（名称）”框中输入 try1，然后点击“OK”；（2.5）在“应用程序类型”中，选择“单文档”；

（2.6）点击“Finish（完成）”。

（3）执行编译和连接，生成可执行程序

（4）执行程序，观察运行结果：

（4.1）点击菜单“Debug?Start Debugging”或按F5

（4.2）点击菜单“Debug?Start Without Debugging”或按Ctrl＋F5

（5）观察项目结构

（5.1）展开解决方案中的项目树，观察项目文件组成；

（5.2）打开各文件，浏览文件中的基本内容；

（5.3）切换到类视图和资源视图，进一步观察各内容。

（6）增加自定义菜单

（6.1）在项目的资源视图中打开菜单资源；（6.2）增加一个顶层菜单“课程设计”；

（6.3）在该顶层菜单下增加一个下拉菜单“msg”，观察该菜单的属性；

（6.4）选中“msg”菜单，按右键，在弹出的快捷菜单中，选择“添加事件处理程序”；（6.5）在弹出的对话框类列表中，选择“Ctry1View”类，确认；（6.6）在void Ctry1View::OnMymenuMsg()函数体中增加下面代码: AfxMessageBox(\这是我做的菜单\运行程序，点击菜单，观察效果；

（6.7）分析代码，看菜单消息是如何与函数相对应的。

（7）增加自定义类以及相关文件

（7.1）在“解决方案”视图中，在头文件文件夹上按右键，选择添加新项，选择头文

件类型，命名为point.h；

（7.2）在新增加的类中，定义一个类，实现“点”类型，要求有x,y坐标（int类型），

- 4 - 4

面向对象课程设计指导书

构造函数，有set和get函数存取坐标，类中的属性必须是私有的，要求类、成员变量、成员函数命名要符合规范；

头文件必须能够处理重复包含的情况，具体细节请参见附录15页。注: 下面是点类的一个参考定义：

（7.3）在源文件文件夹上按右键，选择添加新项，选择C++源文件类型，命名为point.cpp，在该文件中实现点类的函数等。注意在该CPP文件的第一行必须是#include

(7.4) 添加文件后，解决方案看起来应该类似下图效果

（8）在前面定义的菜单函数中，调用设计号的点类，用对话框显示点坐标值。（注：

AfxMessageBox中可以是一般字符串，可以使用sprintf函数转换坐标为字符串）。

该函数的参考代码如下所示：

void Ctry1View::OnMymenuMsg() { }

Point p; char coord[30];

sprintf(coord,\AfxMessageBox(coord);

Point就是要求编写的类。

5. 实习过程中，可以进行下面的尝试：

- 5 - 5

面向对象课程设计指导书

（1）添加菜单后，改变菜单的ID：

（2）在添加菜单消息映射函数的过程中，改变函数名为更加有意义的名字：（3）在生成点对象时，使用缺省构造函数加set函数，使用带参数的构造函数；（4）生成点对象时，使用一般对象定义方式，也可以试验new , delete的方式。（5）复习以前的调试技术（设置断点，单步追踪，观察变量值等）。

- 6 - 6

面向对象课程设计指导书

实习任务1

1. 实习内容（反复练习下列内容，达到实习目标）：

? 锻炼编写基本类；

2. 实习目标（实习结束时请在达到的目标前打勾√）：

（1）掌握public，private在类中的应用；（2）掌握如何编写带参数的构造函数；

（3）掌握如何编写与调用成员函数；

（4）掌握如何在项目中添加多个自定义类以及文件等；（5）初步体会面向对象的编程特点。 3. 上机指南：

（1）启动Visual Studio2005；

（2）创建一个和“预备任务”同样类型的新的项目（包括解决方案），可命名为tryn；（3）熟悉代码，复习编译、调试等菜单和快捷键；（4）编写矩形类，要求使用上次实习的点类做为坐标的类型，需要有计算面积、计算周长，

绘画自己(draw)等成员函数。draw函数目前就是弹出一个对话框，显示自己是矩形，

并显示出坐标；除了缺省构造函数外，添加能够直接定义矩形的带参数的构造函数；

提示：

带参数的构造函数可以把左上角坐标和右下角坐标做为参数，也可以左下角坐

标配合长、宽做参数；

矩形类必须有自己的私有成员变量保存坐标等；下面是矩形类的参考定义：

其中 const Point &p的用法鼓励大家课下讨论其目的，如果对该语法的使用感觉困难，可以用一般方法 “Point p “ 的形式进行参数传递，但是前面一种要好一些。

（5）编写三角形类，也要求有计算面积，计算周长，绘画等成员函数以及特定的构造函数；注：可以考虑用三个定点坐标标识三角形。

- 7 - 7

面向对象课程设计指导书

（6）编写圆形类，也要求有计算面积，计算周长，绘画等成员函数以及特定的构造函数；

注：可以考虑用圆心、半径表示圆。（7）编写正方形类，也要求有计算面积，计算周长，绘画等成员函数以及特定的构造函数；

注：可以考虑用一个定点加上宽度标识正方形。（8）编写图形类(Graph)，每个图形对象包含有一个圆，一个矩形，一个正方形，一个三角

形，图形类有得到总面积，得到总周长，绘画所有图形等功能；

注：可以把图形类考虑为一张画，画里面有一个圆，一个矩形，一个正方形，一个三角形。把这几个形状做为图形类的私有成员变量，通过构造函数或者set函数设置进来，然后利用这些变量实现计算总面积、计算总周长、绘画等功能。

（9）添加一个新菜单，在菜单处理函数中创建一个具体的图形对象，调用该对象的几个方

法，弹出对话框显示结果：

注：图形对象以及里面的圆等形状对象可以直接在程序中进行创建，设置坐标，不需要通过交互输入值。

（10）编译、运行程序，观察结果；若有错，则调试改正；

- 8 - 8

面向对象课程设计指导书

实习任务2

1. 实习内容：

（1）改进实习1编写的程序（重写），利用纯虚基类、继承等重写函数；（2）改进图形类，使之方便地处理多个形状对象。 2. 目标要求（实习结束时请在达到的目标前打勾√）：（1）能够理解并应用继承的概念；（2）能够正确地撰写虚函数；（3）初步体会到多态带来的方便。 3. 上机指南：

（1）以实习1为基础，针对矩形、三角形、正方形、圆形的特点，提取出一个基类（父类），编写该类的方法；

（2）考虑一个合理的名字来命名新的类；

（3）分析提取出的基类的方法是否应该设置为虚函数；

（4）矩形、三角形、正方形、圆形等类需要继承基类，重写相应的虚函数；

注：这里要注意得到面积、得到周长等方法应该声明为virtual函数。

（5）改写图形类，使该类中存储一个形状数组，数组数目可以在程序中用一个宏预定义，

要求数组中存储的对象类型为纯虚基类的指针，重写图形类的几个成员函数，与以前的做对比，分析变化情况；

（6）注意不要产生内存泄漏。

（7）改变数组长度宏的大小，看图形类计算总面积，计算总长度，绘画等代码是否需要改变？改变得是哪些？

（8）扩展要求（本要求不需要一定完成，完成的可以考虑适当加分）：继续改进上面的程

序，把提取出的基类实现为纯虚基类。如果对纯虚基类的概念不熟悉，鼓励进行快速

的自学，掌握这个概念。

- 9 - 9

面向对象课程设计指导书

实习任务3

1. 实习内容：

（1）完善实习2的内容；

（2）在实习2的基础上，更改draw函数，直接在屏幕上绘画出对象的形状。 2. 目标要求（实习结束时请在达到的目标前打勾√）：

（1）巩固实习2要求的目标；

（2）根据示例代码，更改实习2中的代码，实际绘画出图形：

（3）运用调试方法修改、检查和完善程序。 3. 上机指南：

在屏幕上绘图使用是MFC的一些类，这里不要求大家掌握很多，只要能够用就可以了，下面是绘图所需要的一些代码参考。主要先找到OnDraw函数，再根据下面的参考更改程序作出绘画的效果。(注意试验用的坐标不要太大，否则图形可能看不到)。

void Ctry1View::OnDraw(CDC* pDC) {

}

//画圆(300，300)和（400,400）确定了圆的外接正方形 pDC->Ellipse(300,300,400,400); // 添加的画线(100,100)-->(200,200) pDC->MoveTo(100,100); pDC->LineTo(200,200);

Ctry1Doc* pDoc = GetDocument(); ASSERT_VALID(pDoc); if (!pDoc)

return;

上面是基本的绘画函数，可以考虑利用这些函数实现画矩形、画三角形等功能。

注：万一实习3的要求实在达不到，也可以先把实习2中的图形在屏幕上进行绘画，如果绘画成功，也算完成本实习任务。

- 10 - 10

面向对象课程设计指导书

实习任务4

1. 实习内容：

(1) 完善实习3的功能；

(2) 增加新的方法，体验程序维护的工作。 2. 目标要求（实习结束时请在达到的目标前打勾√）：

(1) 实习3的任务确实已经完成； (2) 增加了新的方法；

(3) 初步具有到了程序不断改进的经验； 3. 上机指南：

（1）在实习3程序的基础上，在每个形状上添加一个函数isSelected，参数为一个点坐

标，如果点在形状内部或者边界上，返回真，否则返回假；（2）在图形对象中添加一个函数，传入一个点坐标，把选中的形状列表返回来；（3）增加一个菜单，测试是否正确选择了对象，弹出对话框显示选择结果；（4）第3步通过后，更改OnDraw中的代码，使程序只显示被选中的形状。（注：图

形中的形状对象以及选择点可以直接写在程序中，不需要交互输入）。

- 11 - 11

面向对象课程设计指导书

实习任务5

1. 实习内容：

(1) 体会多个对象之间的组合； (2) 编写调试程序。

2. 目标要求（实习结束时请在达到的目标前打勾√）：

(1) 能够编写要求的多个类；

(2) 初步体会到面向对象编程所表现出的整体与部分的概念； 3. 上机指南：

(1) 根据汽车的结构，构造一组类，简单描述汽车；

(2) 编写发动机类(Engine) 有启动、停止、转动等方法； (3) 编写窗户类(Window)，有摇上、摇下等方法；

(4) 编写车轮类（Wheel），有调整方向方法，带角度参数；

(5) 编写车门类(Door)，有打开、关闭等方法，有窗户属性； (6) 编写一个汽车类（Car），由2扇门、4个车轮、一个发动机组成，撰写一个驾驶函数，模拟开车场景，比如关上车门，摇上窗户，发动发动机，调整方向等； (7) 要求用对话框显示汽车状态。

- 12 - 12

面向对象课程设计指导书

实习任务6

1. 实习内容：

(1) 熟练文件读写功能；

(2) 编写调试程序。

2. 目标要求（实习结束时请在达到的目标前打勾√）： (1) 能够熟练的读写文件；

(2) 能够主动将功能相对独立的代码封装成函数； 3. 上机指南：统计学生成绩

从文本文件中读某班学生的学号、姓名和成绩，进行分析给出平均分、最高分、最低分、最大分数差、标准差、各学生的名次，把结果输出到文件中。其中：

_平均分：x?1nn?xi?1i

标准差：s?1ni?(xni?1_?x)2

最大分数差=最高分-最低分

注：该任务属于扩展任务，不需要所有的同学完成。完成者可加分。

- 13 - 13

面向对象课程设计指导书

四、成绩评定及评分标准

由指导教师根据课程设计任务完成情况、现场提问、观看运行结果、评阅课程设计报告并参考学生平时表现等五方面给出课程设计成绩。

1、具体评分标准（见表5-1），成绩等级分为：A（100分）、B（80分）、C（70分）、D（60分）、E（<60分）五档或折合成百分制给出成绩。

表5-1 VC++课程设计评分暂行标准

评分标准（ABCDE）项目评定内容 A 完成设计题目的超额完成设计题目，达到较高的程序设计水平，具有一定的创新性、数量与质量（X1）实用性。课堂检查提问检查基础理回答问题准确合理，概念表达清论掌握情况（X2）楚、有条理。调试能力和软件评D 分基本完成课程设计要求基本符合问题要求具有较强的调试程序的能力，操作程序运行结熟练，程序运行结果正确，界面友果基本符合运行检查（X3）好，界面结构合理。要求课程设计报告严格按照课程设计报告格式的要课程设计报告情况检查（X4）求，设计文档规范；书写清晰有条基本达到课理，图文并貌，能够总结算法或设程设计报告计的优缺点，附有改进意见、设计的要求体会或心得。严格遵守机房规定，不迟到不早退，不做与课程设计无关的事情总分＝（X1 +X2 +X3 +X4 +X5）/5 基本能按要求进行课程设计平时表现总分

出勤记载（X5） 2、指导老师按优秀、良好、中等、及格、不及格五档提交成绩，成绩等级如下：

优秀：90-100；

良好：80-89；中等：70-79；及格：60-69；

不及格：<60，成绩不合格者需要重修。

- 14 - 14

面向对象课程设计指导书

附件一、C++编码规范

1、文件组织

（1）文件结构

A、版权和版本的声明

版权和版本的声明位于头文件和定义文件的开头（参见例1），主要内容有： ① 版权信息。

② 文件名称，标识符，摘要。

③ 当前版本号，作者/修改者，完成日期。 ④ 版本历史信息。

//Copyright (c) 2002-2005, 中国地质大学 // All rights reserved. // // 文件名称：输入文件名，如filename.h // 文件标识：见配置管理计划书 // 摘要：简要描述本文件的内容 // // 当前版本：1.1 // 作者：输入作者（或修改者）名字 // 完成日期：2002年7月20日 // // 取代版本：1.0 // 原作者：输入原作者（或修改者）名字 // 完成日期：2002年5月10日例1 版权和版本的声明

B、头文件的结构

头文件由三部分内容组成： ① 头文件开头处的版权和版本声明（参见例1）。 ② 预处理块。

③ 函数和类结构声明等。

假设定义文件的名称为 box.h，定义文件的结构参见例2。

- 15 - 15

面向对象课程设计指导书

// 版权和版本声明见例1，此处省略。 #include “graphics.h” // 引用头文件 … // 全局函数的声明 void Function1(…); ; // 类的声明 class CBox{ public: long GetSize(); … private: long m_lWidth; …. }; 例2 C++/C定义文件的结构

【规则1】防止头文件内容被重复包含

为了防止头文件内容被重复包含，所有头文件必须用ifndef/define/endif结构产生预处理块。例如：对于文件mystring.h，其文件内容应按照如下方式编写（例3）：

#ifndef MYSTRING_H #define MYSTRING_H #include // 引用标准库的头文件 … #include “myheader.h” // 引用非标准库的头文件 … void Function1(…); … class Box { … }; … #endif 例3 文件的内容定义

// 全局函数声明 // 类结构声明【规则2】引用信息顺序

标准的头文件要放在前面，而且按照字母顺序排列。标准头文件和自己的头文件之间应该用空行分隔。

- 16 - 16

面向对象课程设计指导书

【规则3】用 #include 格式来引用标准库的头文件（编译器将从标准库目录开始搜索）。【规则4】用 #include “filename.h” 格式来引用非标准库的头文件（编译器将从用户的工作目录开始搜索）。【建议1】头文件中只存放“声明”而不存放“定义”

在C++语法中，类的成员函数可以在声明的同时被定义，并且自动成为内联函数，如果从提高性能角度考虑是可取。除此之外的选择，建议将成员函数的定义与声明分开，不论该函数体有多么小。

【建议2】不提倡使用全局变量，尽量不要在头文件中出现象extern int value 这类声明。

C、头文件的作用

① 通过头文件来调用库功能。在很多场合，源代码不便（或不准）向用户公布，只要向用户提供头文件和二进制的库即可。用户只需要按照头文件中的接口声明来调用库功能，而不必关心接口怎么实现的，编译器会从库中提取相应的代码。

② 头文件能加强类型安全检查。如果某个接口被实现或被使用时，其方式与头文件中的声明不一致，编译器就会指出错误，这一简单的规则能大大减轻程序员调试、改错的负担。

（2）目录结构

如果一个软件的头文件数目比较多（如超过十个），通常应将头文件和定义文件分别保存于不同的目录，以便于维护。例如，可将头文件保存于include目录，将定义文件保存于source目录（可以是多级目录）。

如果某些头文件是私有的，它不会被用户的程序直接引用，则没有必要公开其“声明”。为了加强信息隐藏，这些私有的头文件可以和定义文件存放于同一个目录。【规则5】统一目录结构

项目开始时，规定好项目相关文件在磁盘上的存储目录结构。

2、命名规则

比较著名的命名规则当推Microsoft公司的“匈牙利”法，该命名规则的主要思想是“在变量和函数名中加入前缀以增进人们对程序的理解”。例如所有的字符变量均以ch为前缀，若是指针变量则追加前缀p，如果一个变量由ppch开头，则表明它是指向字符指针的指针。在程序体中应基本遵循匈牙利命名规则。

（1）总则

【规则6】标识符应当直观且可以拼读，可望文知意，不必进行“解码”。

标识符应该采用英文单词或其组合，便于记忆和阅读，切忌使用汉语拼音来命名。

【规则7】标识符长度应当尽量符合“min-length && max-information”原则。

单字符的名字也是有用的，常见如i，j，k，m，n，x，y，z等，它们通常可用作函数内的局部变量。

- 17 - 17

面向对象课程设计指导书

【规则8】程序中不要出现仅靠大小写区分的相似的标识符。例如： int x, X; // 变量x 与 X 容易混淆 void foo(int x); // 函数foo 与FOO容易混淆 void FOO(float x); 【规则9】命名规则尽量与所采用的操作系统或开发工具的风格保持一致。

例如Windows应用程序的标识符通常采用“大小写”混排的方式，如AddChild。而Unix应用程序的标识符通常采用“小写加下划线”的方式，如add_child。别把这两类风格混在一起用。【建议3】尽量避免名字中出现数字编号，如Var1，Var2等，除非逻辑上的确需要编号。【建议4】尽量使用公认的无异义的缩写，缩写一般不超过4个字母。

例如： HTML Hypertext Markup Language URL Uniform Resource Locator cmd command init initialize 【规则10】程序中不要出现标识符完全相同的局部变量和全局变量，尽管两者的作用域不同而不会发生语法错误，但会使人误解。

【规则11】变量的名字应当使用“名词”或者“形容词＋名词”。

例如： float value; float oldValue; float newValue; 【规则12】函数的名字应当使用“动词”或者“动词＋名词”（动宾词组）。类的成员函数省掉表示

对象本身的“名词”。

例如： DrawBox();

box->Draw(); // 全局函数 // 类的成员函数【规则13】用正确的反义词组命名具有互斥意义的变量或相反动作的函数等。

例如： int minValue; int maxValue; int SetValue(…); int GetValue(…);

（2）文件

- 18 - 18

面向对象课程设计指导书

【规则14】通用文件命名规则

① 类的声明文件（.h）和实现文件（.cpp）：类名.h类名.cpp

② 常量定义文件：项目名称缩写（大写）+_Const.h 例：DI_Const.h ③ 全局变量、函数声明文件：项目名称缩写（大写）+_GlobalDef.h 例：DI_GlobalDef.h ④ 错误代码定义文件：项目名称缩写（大写）+_ErrorDef.h 例：DI_ErrorDef.h

（3）变量

【规则15】变量名由范围前缀+类型前缀+限定词组成。【规则16】变量和参数用小写字母开头的单词组合而成。

例如： BOOL flag; int drawMode; 【规则17】变量的范围前缀 ① 全局变量加上g_（表示global）例如： int g_howManyPeople; // 全局变量 int g_howMuchMoney; // 全局变量 ② 静态变量加上s_ 例如： void Init(…) { static int s_initValue; … } ③ 局部变量范围前缀为空【规则18】变量的类型前缀

类型名称整型长整型无符号整型无符号长整型字符布尔量表示符号 n l u dw ch b - 19 - 19

// 静态变量范例 m_nTotalNum g_lOpenDate uMsgID dwCardNo chChar m_bOK 面向对象课程设计指导书

浮点数双精度浮字符数组指针字节指针无符号指针字符指针整型指针文件指针结构体【规则19】方法参数名

f d sz p pb pv lpsz lpn fp st m_fPrice g_dRate m_szPath pProgress m_pbSendData g_pvParam lpszNameStr lpnSysDoomType m_fpFile stMyStruct 使用有意义的参数命名，如果可能的话，使用和要赋值的字段一样的名字。例如： void setTopic (String strTopic) { this.strTopic = strTopic; ... } 【建议5】循环变量

可以用i，j，k做循环变量，用p，q做位移变量。【规则20】常量名全用大写，用下划线分割单词

例如：

const int MAX = 100; const int MAX_LENGTH = 100; （4）自定义类型

【规则21】类名

必须由大写字母开头的单词或缩写组成，只用英文字母，禁用数字、下划线等符号。【规则22】typedef定义的类型

利用typedef创建类型名为以“S”加单词或缩写组成，只用英文字母。

【规则23】枚举类型

枚举类型名以“E”加单词或缩写组成，只用英文字母。枚举类型的成员遵循常量命名约定，使用大写字母和下划线，名称要有含义。【规则24】结构（struct）和联合（union）

- 20 - 20

面向对象课程设计指导书

结构（struct）和联合（union）名同类名。

（5）函数

【规则25】用正确的反义词组命名具有互斥意义的变量或相反动作的函数等。【规则26】函数的名字应当使用“动词”或者“动词＋名词”（动宾词组）。

【规则27】类方法名必须用一个小写字母的动词开头，后面的单词用大写字母。例如：getName()，setHTML()

【建议6】方法名前缀

根据需要使用get/set存取属性值，is/has/should存取布尔值。推荐使用下列方法前缀，按下列组合配对使用：

add/remove，create/destroy，old/new，insert/delete，increment/decrement，start/stop， begin/end，first/last，up/down，next/previous，min/max，open/close，show/hide

3、注释

（1）总则

【规则28】程序可以有两种注释：代码注释（implementation comments）和文档注释（documentation comments）。代码注释主要删除注释（注释掉目前不需要的代码）和说明注释（对代码进行说明），文档注释是指专门用来形成文档用的注释。【规则29】注释是Why而不是What。程序中的注释不可喧宾夺主，注释的花样要少。

【规则30】边写代码边注释，修改代码同时修改相应的注释，以保证注释与代码的一致性。不再有用的注释要删除。

【规则31】注释的位置应与被描述的代码相邻，可以放在代码的上方或右方，不可放在下方。【规则32】当代码比较长，特别是有多重嵌套时，应当在一些段落的结束处加注释，便于阅读。【规则33】修正bug之后，要加上描述修改状况的注释。

（2）文档注释

【规则34】文档注释

文档注释用/**……*/标识，它对代码的使用说明进行描述，每一个文档注释被放进/**……*/分隔符，每一个类、接口、构造函数，方法和成员变量拥有一个注释，这样的注释应该出现在相应的声明前。

- 21 - 21

面向对象课程设计指导书

例如： /** * Example类提供如下的功能 ... */ class Example { …… } 类和接口的文档注释（/**）的第一行不应该缩进，以后的文档注释每行都应有一个空格的缩进（给垂直排列的星号）。成员函数（包括构造函数），第一行文档注释前有一个Tab缩进，后续的行有一个Tab外加一个空格的缩进。对于那些不适于文档注释的类、接口、变量、方法的信息，用代码注释进行说明，而不应该在类的文档注释中。文档注释不应该放在方法或构造函数的定义体内。

（3）源程序文件

【规则35】源程序文件文档注释

每个源程序文件的开头都需要文档注释（参见例1），主要内容有：

② 文件名称：本文件的名称。 ③ 开发者姓名：填写最初编写此代码的人。 ④ 创建日期：本文件的创建日期。

⑤ 功能目的：简要描述本文件中代码的功能。 ⑥ 修改历史（修改日期、修改人、修改编号、修改内容）。其中修改历史可以多次出现，任何对本文件的修改必须增加一条修改历史。

（4）类

【规则36】类注释

每个类的必须有文档注释，其中至少要包括：功能、版本、最后修改时间、作者、修改历史（修改日期、修改人、修改编号、修改内容）等，其中修改历史可以多次出现，任何对本类的修改必须增加一条修改历史，此外可以根据需要添加其它相关信息或链接。类注释必须在类的声明之前。

- 22 - 22

面向对象课程设计指导书

例例如： /** * 类 String 封装了有关字符串的操作，这些操作包括 * 单个字符定位、串比较、查找、提取子串、大写/小写转换等 * * @author Lee Boynton * @author Arthur van Hoff * @version 1.130, 02/09/01 */ class String { }

… （5）函数

【规则37】函数注释

所有函数（包括类自定义类型的成员函数）必须有文档注释。注释在其定义之前，按如下方式书写：

/** * 判断一字符串是否为数字 * * @param sNum 字符串 * @return true=是数字 false=不是数字 */ boolean isNumber(String sNum) { ... } 【规则38】构造函数

注释要标明此函数为构造函数。如果有多个构造函数，用递增的方式书写，参数多的写在后面，如有多组构造函数，每组分别用递增的方式写，并且每一个都要有详细的注释。

（6）变量

【规则39】变量的注释

变量注释出现在变量声明或自定义数据类型成员声明的前一行，用以描述对应变量的作用和含义，变量注释一般占一行。下列变量必须有注释：

① 自定义类型的成员

② 全局变量 ③ 其它重要的局部变量注释必须按如下方式书写：

- 23 - 23

面向对象课程设计指导书

/** * 包计数器 */ int iPackets;

（7）语句

【建议7】代码注释风格

代码注释用/*...*/和//标识。程序可以有四种风格的代码注释：块注释、单行注释、后缘注释（trailing）、行尾注释（end-of-line）。

块注释。块注释常用来提供文件、方法、数据结构、算法的说明。块注释可以被用在每个文件的开头和每个方法的起始，它们也可以被用在其他地方，比如在方法内部等。块注释在函数或方法的内部应该和它们描述的代码具有同样的缩进格式。块注释之前应该有一个空行。

单行注释。短的注释可以出现在单行，和它后面的代码使用同样的缩进。单行注释前应该有一个空行。

后缘注释（trailing）和行尾注释（end-of-line）。非常短的注释可以出现在和它说明的代码的同一行中，但应该和被说明的代码相隔足够远。如果在一个代码块中出现了多于一个的短注释，它们应该有相同的缩进。

【规则40】语句块结束注释

① 函数定义的结束必须加如下内容的注释： //end of 函数名。若程序文件中能够明确指出函数结束的不需加此注释。 ② 对于包含代码行较多的条件语句，每个条件处理语句块的结束必须加如下内容的注释：//end of 此语句块的条件。

③ 对于包含代码行较多的循环语句，循环语句块的结束必须如下内容的注释：//end of 循环条件。

4、程序的版式

（1）空白符

A、空行

【规则41】在每个类声明之后、每个函数定义结束之后都要加空行。

【规则42】在一个函数体内，逻辑上密切相关的语句之间不加空行，其它地方应加空行分隔。

B、空格

【规则43】在if、for、while等关键字之后应留一个空格再跟左括号?(?，以突出关键字。【规则44】函数名之后不要留空格，紧跟左括号?(?，以与关键字区别。【规则45】?,?、?;?向前紧跟，紧跟处不留空格。

- 24 - 24

面向对象课程设计指导书

【规则46】?,?之后要留空格，如Function(x, y, z)。如果?;?不是一行的结束符号，其后要留空格，如for (initialization; condition; update)。

【规则47】赋值操作符、比较操作符、算术操作符、逻辑操作符、位域操作符，如“=”、“+=”“>=”、“<=”、“+”、“*”、“%”、“&&”、“||”、“<<”、“^”等二元操作符的前后应当加空格。

【规则48】一元操作符如“!”、“~”、“++”、“--”、“&”（地址运算符）与其作用的操作数之间不加空格。

【规则49】操作符“［］”、“.”、“->”前后不加空格。

C、对齐

【规则50】相互匹配的?{?和?}?应独占一行并且位于同一列，同时与引用它们的语句左对齐。【规则51】{ }之内的代码块在新行?{?右边一个Tab处左对齐。

（2）表达式

A、运算符的优先级

【建议8】建议对于除+，*等优先级非常明显的运算符之外，全部使用括号确定表达式的操作顺序。

B、复合表达式

【规则52】不要有多用途的复合表达式。

C、逻辑表达式

? 布尔变量与零值比较

【规则53】布尔变量与零值比较

不可将布尔变量直接与TRUE、FALSE或者1、0进行比较。应写为：

bool bFlag;

if (bFlag) // 表示flag为真 if (!bFlag) // 表示flag为假

其它的用法都属于不良风格，

例如： if (flag == TRUE) if (flag == 1 ) if (flag == FALSE) if (flag == 0) ? 整型变量与零值比较

【规则54】应当将整型变量用“==”或“！=”直接与0比较。

假设整型变量的名字为value，它与零值比较的标准if语句如下：

if (value == 0) if (value != 0)

- 25 - 25

面向对象课程设计指导书

不可模仿布尔变量的风格而写成：

if (value) // 会让人误解 value是布尔变量

if (!value)

? 浮点变量与零值比较

【规则55】不可将浮点变量用“==”或“！=”与任何数字比较。

千万要留意，无论是float还是double类型的变量，都有精度限制。所以一定要避免将浮点变量用“==”或“！=”与数字比较，应该设法转化成“>=”或“<=”形式。

假设浮点变量的名字为x，应当将

if (x == 0.0) // 隐含错误的比较

转化为

if ((x>=-EPSINON) && (x<=EPSINON))

其中EPSINON是允许的误差（即精度）。 ? 指针变量与零值比较

【规则56】应当将指针变量用“==”或“！=”与NULL比较，而不应采用if(p)或者if(!p)的形式。指针变量的零值是“空”（记为NULL）。尽管NULL的值与0相同，但是两者意义不同。假设指针变量的名字为p，它与零值比较的标准if语句如下：

if (p == NULL)

// p与NULL显式比较，强调p是指针变量

// 容易让人误解p是整型变量

if (p != NULL)

不要写成

if (p == 0)

if (p != 0) 或者

if (p) // 容易让人误解p是布尔变量

if (!p)

（3）基本语句

A、代码行

【规则57】一行代码只做一件事情，如只定义一个重要变量，或只写一条语句。

【规则58】if、for、while、do等语句自占一行，执行语句不得在同一行上。不论执行语句有多少都要加{}。

【规则59】尽可能在定义变量的同时初始化该变量（就近原则）。【建议9】在使用之前才定义变量。

【建议10】不提倡使用全局变量

不提倡使用全局变量，尽量不要在头文件中出现象extern int value 这类声明。【建议11】调试信息

不要用cout到处打印调试信息，统一使用带开关的调试类打印调试信息。

B、长行拆分

【规则60】代码行最大长度为80个字符。

- 26 - 26

面向对象课程设计指导书

【规则61】超长的语句应该在一个逗号后，或者一个操作符前折行，操作符放在新行之首（以便突出操作符）。拆分出的新行要进行适当的缩进，使排版整齐，语句可读。

C、修饰符的位置

【规则62】应当将修饰符 * 和＆紧靠变量名。

（4）条件语句

【建议12】程序中有时会遇到if/else/return的组合，建议将如下风格的程序：

if (condition) return x; return y; 改写为

if (condition) { return x; } else { return y; } 或者改写成更加简练的 return (condition ? x : y); 【规则63】switch语句中必须有default分支。

例如： switch (i) { case 1: …; break; case 2: …; break; default : break; } 【规则64】每个case语句的结尾不要忘了加break，否则将导致多个分支重叠（除非有意使多个分支重叠）。

- 27 - 27

面向对象课程设计指导书

（5）循环语句

【规则65】在多重循环中，如果有可能，应当将最长的循环放在最内层，最短的循环放在最外层，以减少CPU跨切循环层的次数。

如：下面例4(b)的效率比例4(a)的高。

for (row=0; row<100; row++) { for ( col=0; col<5; col++ ) { sum = sum + a[row][col]; } } } 例4 (a) 低效率：长循环在最外层例4 (b) 高效率：长循环在最内层

for (col=0; col<5; col++ ) { for (row=0; row<100; row++) { sum = sum + a[row][col]; } 【规则66】如果循环体内存在逻辑判断，并且循环次数很大，宜将逻辑判断移到循环体的外面。如：例5(a)的程序比例5(b)多执行了N-1次逻辑判断。并且由于前者老要进行逻辑判断，打断了循环“流水线”作业，使得编译器不能对循环进行优化处理，降低了效率。如果N非常大，最好采用例5(b)的写法，可以提高效率。如果N非常小，两者效率差别并不明显，采用例5(a)的写法比较好，因为程序更加简洁。

for (i=0; i

【规则67】不可在for 循环体内修改循环变量，防止for 循环失去控制。【建议13】建议for语句的循环控制变量的取值采用“半开半闭区间”写法。

如：例6(a)中x值属于半开半闭区间“0 =< x < N”，起点到终点的间隔为N，循环次数为N。例6(b)中的x值属于闭区间“0 =< x <= N-1”，起点到终点的间隔为N-1，循环次数为N。相比之下，例6(a)的写法更加直观，尽管两者的功能是相同的。

for (int x=0; x

- 28 - 28

for (int x=0; x<=N-1; x++) { … 面向对象课程设计指导书

（6）常量

【规则68】静态变量使用时使用类名::变量名的方法来调用。

【规则69】尽量使用含义直观的常量来表示那些将在程序中多次出现的数字或字符串。【规则70】在C++程序中只使用const常量而不使用宏常量，即const常量完全取代宏常量，const有类型的检查而宏没有。

【规则71】常量定义的位置。需要对外公开的常量放在头文件中，不需要对外公开的常量放在定义文件的头部。为便于管理，可以把不同模块的常量集中存放在一个公共的头文件中。

【规则72】常量意义要明确。如果某一常量与其它常量密切相关，应在定义中包含这种关系，而不应给出一些孤立的值。

例如： const float RADIUS = 100; const float DIAMETER = RADIUS * 2; // 不要写成 DIAMETER = 200;

（7）类中的常量

有时我们希望某些常量只在类中有效。由于#define定义的宏常量是全局的，不能达到目的，于是想当然地觉得应该用const修饰数据成员来实现。const数据成员的确是存在的，但其含义却不是我们所期望的。const数据成员只在某个对象生存期内是常量，而对于整个类而言却是可变的，因为类可以创建多个对象，不同的对象其const数据成员的值可以不同。

不能在类声明中初始化const数据成员。以下用法是错误的，因为类的对象未被创建时，编译器不知道SIZE的值是什么。

class A

{…

onst int SIZE = 100; //错误，企图在类声明中初始化const数据成员 int array[SIZE]; // 错误，未知的SIZE };

const数据成员的初始化只能在类构造函数的初始化表中进行。

例如：

class A // 构造函数 {… A(int size); const int SIZE ; }; A::A(int size) : SIZE(size) { … } A a(100); A b(200); // 构造函数的初始化表 // 对象 a 的SIZE值为100 // 对象 b 的SIZE值为200 - 29 - 29 面向对象课程设计指导书

怎样才能建立在整个类中都恒定的常量呢？别指望const数据成员了，应该用类中的枚举常量来实现。

例如： class A {… enum { SIZE1 = 100, SIZE2 = 200}; // 枚举常量 int array1[SIZE1]; int array2[SIZE2]; };

枚举常量不会占用对象的存储空间，它们在编译时被全部求值。枚举常量的缺点是：它的隐含数据类型是整数，其最大值有限，且不能表示浮点数（如PI=3.14159）。

（8）函数

A、参数

【规则73】参数的书写要完整，在函数定义的地方，不要只写参数的类型而省略参数名字，如果函数没有参数，则用void填充。

例如： void SetValue(int width, int height); // 良好的风格 void SetValue(int, int); // 不良的风格 float GetValue(void); float GetValue(); // 良好的风格 // 不良的风格【规则74】参数命名要恰当，顺序要合理，一般地，应将目的参数放在前面，源参数放在后面。

例如编写字符串拷贝函数StringCopy，它有两个参数。如果把参数名字起为str1和str2，例如： void StringCopy(char *str1, char *str2);

那么我们很难搞清楚究竟是把str1拷贝到str2中，还是刚好倒过来。可以把参数名字起得更有意义，如叫strSource和strDestination，这样从名字上就可以看出应该把strSource拷贝到strDestination。

还有一个问题，这两个参数哪一个该在前哪一个该在后？参数的顺序要遵循程序员的习惯。一般地，应将目的参数放在前面，源参数放在后面。

如果将函数声明为：

void StringCopy(char *strSource, char *strDestination); 别人在使用时可能会不假思索地写成如下形式：

char str[20];

StringCopy(str, “Hello World”); // 参数顺序颠倒

【规则75】指针入参

如参数是指针，且仅作输入用，则应在类型前加const，以防止该指针在函数体内被意外修改。

- 30 - 30

面向对象课程设计指导书

例如： void StringCopy(char *strDestination，const char *strSource); 【规则76】值传递对象

如果输入参数以值传递的方式传递对象，则宜改用“const &”方式来传递，这样可以省去临时对象的构造和析构过程，从而提高效率。

【规则77】输入参数

对于非基本数据类型的输入参数，应该将“值传递”的方式改为“const引用传递”，目的是提高效率；对于基本数据类型的输入参数，不要将“值传递”的方式改为“const引用传递”。

【建议14】避免函数有太多的参数，参数个数尽量控制在5个以内。如果参数太多，在使用时容易将参数类型或顺序搞错。

【建议15】尽量不要使用类型和数目不确定的参数。

C标准库函数printf是采用不确定参数的典型代表，其原型为：

int printf(const chat *format[, argument]…);

这种风格的函数在编译时丧失了严格的类型安全检查。

B、返回值

【规则78】不要省略返回值的类型。

C语言中，凡不加类型说明的函数，一律自动按整型处理，这样做不会有什么好处，却容易被误解为void类型。

C++语言有很严格的类型安全检查，不允许上述情况发生。由于C++程序可以调用C函数，为了避免混乱，规定任何C++/C函数都必须有类型，如果函数没有返回值，那么应声明为void类型。

【规则79】函数名字与返回值类型在语义上不可冲突。

违反这条规则的典型代表是C标准库函数getchar。例如： char c; c = getchar(); if (c == EOF) … 按照getchar名字的意思，将变量c声明为char类型是很自然的事情。但不幸的是getchar的确不是char类型，而是int类型，其原型如下： int getchar(void);

由于c是char类型，取值范围是[-128，127]，如果宏EOF的值在char的取值范围之外，那么if语句将总是失败，这种“危险”人们一般哪里料得到！导致本例错误的责任并不在用户，是函数getchar误导了使用者。

【规则80】不要将正常值和错误标志混在一起返回。正常值用输出参数获得，而错误标志用return语句返回。

回顾上例，C标准库函数的设计者为什么要将getchar声明为令人迷糊的int类型呢？他会那么傻吗？

在正常情况下，getchar的确返回单个字符。但如果getchar碰到文件结束标志或发生读错误，

- 31 - 31

面向对象课程设计指导书

它必须返回一个标志EOF。为了区别于正常的字符，只好将EOF定义为负数（通常为负1）。因此函数getchar就成了int类型。

我们在实际工作中，经常会碰到上述令人为难的问题。为了避免出现误解，我们应该将正常值和错误标志分开。即：正常值用输出参数获得，而错误标志用return语句返回。

函数getchar可以改写成 BOOL GetChar(char *c);

虽然gechar比GetChar灵活，例如 putchar(getchar()); 但是如果getchar用错了，它的灵活性又有什么用呢？

【建议16】有时候函数原本不需要返回值，但为了增加灵活性如支持链式表达，可以附加返回值。

例如：字符串拷贝函数strcpy的原型： char *strcpy(char *strDest，const char *strSrc); strcpy函数将strSrc拷贝至输出参数strDest中，同时函数的返回值又是strDest。这样做并非多此一举，可以获得如下灵活性： Cha char str[20]; nt length = strlen( strcpy(str, “Hello World”) ); 【建议17】如果函数的返回值是一个对象，有些场合用“引用传递”替换“值传递”可以提高效率，而有些场合只能用“值传递”而不能用“引用传递”，否则会出错。

例如：class String {… // 赋值函数 String & operate=(const String &other); // 相加函数，如果没有friend修饰则只许有一个右侧参数 friend String operate+( const String &s1, const String &s2); private:

char *m_data; } String的赋值函数operate = 的实现如下： String & String::operate=(const String &other) { if (this == &other) } 对于赋值函数，应当用“引用传递”的方式返回String对象。如果用“值传递”的方式，虽然功能仍然正确，但由于return语句要把 *this拷贝到保存返回值的外部存储单元之中，增加了不必要的开销，降低了赋值函数的效率。

return *this; delete m_data; m_data = new char[strlen(other.data)+1]; strcpy(m_data, other.data); return *this; // 返回的是 *this的引用，无需拷贝过程 - 32 - 32

面向对象课程设计指导书

例如： String a,b,c; … a = b; a = b = c; // 如果用“值传递”，将产生一次 *this 拷贝 // 如果用“值传递”，将产生两次 *this 拷贝 StrString的相加函数operate + 的实现如下： String operate+(const String &s1, const String &s2) { String temp; delete temp.data; // temp.data是仅含?\\0?的字符串 temp.data = new char[strlen(s1.data) + strlen(s2.data) +1]; strcpy(temp.data, s1.data); strcat(temp.data, s2.data); return temp; } 对于相加函数，应当用“值传递”的方式返回String对象。如果改用“引用传递”，那么函数返回值是一个指向局部对象temp的“引用”。由于temp在函数结束时被自动销毁，将导致返回的“引用”无效。例如：

C、函数内部实现

不同功能的函数其内部实现各不相同，看起来似乎无法就“内部实现”达成一致的观点，但可以在函数体的“入口处”和“出口处”从严把关，从而提高函数的质量。

【规则81】在函数体的“入口处”，对参数的有效性进行检查。

很多程序错误是由非法参数引起的，我们应该充分理解并正确使用“断言”（assert）来防止此类错误。

【规则82】在函数体的“出口处”，对return语句的正确性和效率进行检查。

如果函数有返回值，那么函数的“出口处”是return语句。我们不要轻视return语句，如果return语句写得不好，函数要么出错，要么效率低下。

注意事项如下： ① return语句不可返回指向“栈内存”的“指针”或者“引用”，因为该内存在函数体结束时被自动销毁。

例如： char * Func(void) { char str[] = “hello world”; } - 33 - 33

c = a + b;

此时 a + b 并不返回期望值，c什么也得不到，留下了隐患。

// str的内存位于栈上 … return str; // 将导致错误面向对象课程设计指导书

② 要搞清楚返回的究竟是“值”、“指针”还是“引用”。 ③ 如果函数返回值是一个对象，要考虑return语句的效率。例如：

return String(s1 + s2);

这是临时对象的语法，表示“创建一个临时对象并返回它”。不要以为它与“先创建一个局部对

象temp并返回它的结果”是等价的，如

String temp(s1 + s2); return temp; 实质不然，上述代码将发生三件事。首先，temp对象被创建，同时完成初始化；然后拷贝构造函数把temp拷贝到保存返回值的外部存储单元中；最后，temp在函数结束时被销毁（调用析构函数）。然而“创建一个临时对象并返回它”的过程是不同的，编译器直接把临时对象创建并初始化在外部存储单元中，省去了拷贝和析构的花费，提高了效率。

类似地，我们不要将

return int(x + y); // 创建一个临时变量并返回它写成

int temp = x + y; return temp;

由于内部数据类型如int，float，double的变量不存在构造函数与析构函数，虽然该“临时变量的语法”不会提高多少效率，但是程序更加简洁易读。

D、构造函数、析构函数与赋值函数

【规则83】初始化表

非基本数据类型的成员对象应当采用初始化表的方式初始化，以获取更高的效率。

【规则84】赋值和拷贝构造函数

如果不打算使用类的赋值函数和拷贝构造函数，那么将这两个函数声明为private成员，并且不提供这两个函数的实现，明确拒绝编译器自动生成这两个函数。

【规则85】析构函数

如果打算从一个类派生出子类，那么将这个类的析构函数声明为virtual。【规则86】赋值函数

类的赋值函数应按下列步骤实现：

① 检查自赋值。实际程序中不会有类似a = a，但是间接的自赋值仍有可能出现。

② 用delete释放原有的内存资源。 ③ 分配新的内存资源，并复制字符串。 ④ 返回本对象的引用，目的是为了实现象 a = b = c 这样的链式表达。注意不要将 return *this 错写成 return this 。

E、重载

【规则87】不能重载C++基本数据类型（如int，float等）的运算符。

【规则88】不能重载?.?，因为?.?在类中对任何成员都有意义，已经成为标准用法。【规则89】不能重载目前C++运算符集合中没有的符号，如#，@，$等。

【规则90】对已经存在的运算符进行重载时，不能改变优先级规则，否则将引起混乱。

- 34 - 34

面向对象课程设计指导书

F、使用断言

程序一般分为Debug版本和Release版本，Debug版本用于内部调试，Release版本发行给用户使用。

断言assert是仅在Debug版本起作用的宏，它用于检查“不应该”发生的情况。例7是一个内存复制函数。在运行过程中，如果assert的参数为假，那么程序就会中止（一般地还会出现提示对话，说明在什么地方引发了assert）。

void *memcpy(void *pvTo, const void *pvFrom, size_t size) { assert((pvTo != NULL) && (pvFrom != NULL)); // 使用断言 byte *pbTo = (byte *) pvTo; // 防止改变pvTo的地址 } byte *pbFrom = (byte *) pvFrom; // 防止改变pvFrom的地址 while(size -- > 0 ) *pbTo ++ = *pbFrom ++ ; return pvTo; 例7 复制不重叠的内存块

assert不是一个仓促拼凑起来的宏。为了不在程序的Debug版本和Release版本引起差别，assert

不应该产生任何副作用，所以assert不是函数，而是宏。程序员可以把assert看成一个在任何系统状态下都可以安全使用的无害测试手段。如果程序在assert处终止了，并不是说含有该assert的函数有错误，而是调用者出了差错，assert可以帮助我们找到发生错误的原因。

在加入assert的地方要写下完整的注释。

【规则91】正确区分非法与错误

使用断言捕捉非法情况。不要混淆非法情况与错误情况之间的区别，后者是必然存在的并且是一定要作出处理的。

【规则92】断言使用时机

对于系统内部使用函数，在函数的入口处，使用断言检查参数的有效性（合法性）。对于开放给用户使用的函数，在函数的入口处，采用错误处理机制检查参数的有效性。

【建议18】在编写函数时，要进行反复的考查，并且自问：“我打算做哪些假定？”一旦确定了的假定，就要使用断言对假定进行检查。

【建议19】一般教科书都鼓励程序员们进行防错设计，但要记住这种编程风格可能会隐瞒错误。当进行防错设计时，如果“不可能发生”的事情的确发生了，则要使用断言进行报警。

G、其它

【建议20】函数的功能要单一，不要设计多用途的函数。【建议21】函数体的规模要小，尽量控制在50行代码之内。

【建议22】尽量避免函数带有“记忆”功能。相同的输入应当产生相同的输出。

带有“记忆”功能的函数，其行为可能是不可预测的，因为它的行为可能取决于某种“记忆状态”。这样的函数既不易理解又不利于测试和维护。在C/C++语言中，函数的static局部变量是函数的“记忆”存储器。建议尽量少用static局部变量，除非必需。

- 35 - 35

面向对象课程设计指导书

【建议23】不仅要检查输入参数的有效性，还要检查通过其它途径进入函数体内的变量的有效性，例如全局变量、文件句柄等。

【建议24】用于出错处理的返回值一定要清楚，让使用者不容易忽视或误解错误情况。

（9）内存管理

【规则93】申请内存后要检查

用malloc或new申请内存之后，应该立即检查指针值是否为NULL。防止使用指针值为NULL的内存。

【规则94】数组赋初值

不要忘记为数组和动态内存赋初值。防止将未被初始化的内存作为右值使用。【规则95】及时释放内存

动态内存的申请与释放必须配对，防止内存泄漏。

【规则96】防止“野指针”

用free或delete释放了内存之后，立即将指针设置为NULL，防止产生“野指针”。【规则97】指针不指向常量数组

避免使用指针指向常量数组，特别对于char类型来说。【规则98】释放数组

在用delete释放对象数组时，留意不要丢了符号?[]?。

（10）类

【规则99】若在逻辑上B是A的“一种”，并且A的所有功能和属性对B而言都有意义，则允许B继承A的功能和属性。

例如，男人（Man）是人（Human）的一种，男孩（Boy）是男人的一种，那么类Man可以从类Human派生，类Boy可以从类Man派生。

class Human { }; class Man : public Human { }; class Boy : public Man { }; … … … 【规则100】如果类A和类B毫不相关，不可以为了使B的功能更多些而让B继承A的功能和属性。

【规则101】若在逻辑上A是B的“一部分”（a part of），则不允许B从A派生，而是要用A和其它东西组合出B。

- 36 - 36

面向对象课程设计指导书

例如眼（Eye）、鼻（Nose）、口（Mouth）、耳（Ear）是头（Head）的一部分，所以类Head应该由类Eye、Nose、Mouth、Ear组合而成，不是派生而成，如下图所示。

class Eye { public: void Look(void); }; class Mouth { public: void Eat(void); }; // 正确的设计，虽然代码冗长。 class Head { public: void void void void Look(void) { m_eye.Look(); } }; }; class Ear { public: void Listen(void); class Nose { public: void Smell(void); Smell(void) { m_nose.Smell(); } Eat(void) { m_mouth.Eat(); } Listen(void) { m_ear.Listen(); } m_eye; private: Eye }; Nose m_nose; Mouth m_mouth; Ear m_ear; 如果允许Head从Eye、Nose、Mouth、Ear派生而成，那么Head将自动具有Look、 Smell、Eat、Listen这些功能。下例十分简短并且运行正确，但是这种设计方法却是不对的。

// 功能正确并且代码简洁，但是设计方法不对。 class Head : public Eye, public Nose, public Mouth, public Ear { }; 很多程序员经不起“继承”的诱惑而犯下设计错误。“运行正确”的程序不见得是高质量的程序，此处就是一个例证。

5、可移植性

【建议26】尽可能遵循相应编程语言的标准。

- 37 - 37

面向对象课程设计指导书

C++遵循ISO/IEC 14882-1998标准，C遵循ANSI C标准。【建议27】首先编写可移植的代码，需要时再考虑优化问题。

【规则102】将依赖于平台的代码和不依赖平台的代码组织到不同的源文件中。【建议28】避免使用硬编码数字常量。

【建议29】在一开始就注意与平台相关的细节，如路径的写法，文件名的大小写。

6、提高程序的效率

程序的时间效率是指运行速度，空间效率是指程序占用内存或者外存的状况。

全局效率是指站在整个系统的角度上考虑的效率，局部效率是指站在模块或函数角度上考虑的效率。

【规则103】不要一味地追求程序的效率，应当在满足正确性、可靠性、健壮性、可读性等质量因素的前提下，设法提高程序的效率。