编程规范和范例

目 录
1 排 版 6
2 注 释 11
3 标 识 符 命 名 18
4 可 读 性 20
5 变 量 、 结 构 22
6 函 数 、 过 程 28
7 可 测 性 36
8 程 序 效 率 40
9 质 量 保 证 44
10 代 码 编 辑 、 编 译 、 审 查 50
11 代 码 测 试 、 维 护 52
12 宏 53

软 件 编 程 规 范 总 则
1 排 版
1 排 版
¹1-1: 程 序 块 要 采 用 缩 进 风 格 编 写 , 缩 进 的 空 格 数 为 4 个 ⃞
说 明 : 对 于 由 开 发 工 具 自 动 生 成 的 代 码 可 以 有 不 一 致 ⃞
¹1-2: 相 对 独 立 的 程 序 块 之 间 、 变 量 说 明 之 后 必 须 加 空 行 ⃞
示 例 : 如如 下 例 子 不 符 合 规 范 ⃞
if (!valid_ni(ni))
{
... // program code
}
repssn_ind = ssn_data[index].repssn_index;
repssn_ni = ssn_data[index].ni;
应 如如 下 书 写
if (!valid_ni(ni))
{
... // program code
}
repssn_ind = ssn_data[index].repssn_index;
repssn_ni = ssn_data[index].ni;
¹1-3: 较 长 的 语 句 (>80 字 符 ) 要 分 成 多 行 书 写 , 长 表 达 式 要 在 低 优 先 级 操 作 符 处 划 分 新 行 ,
操 作 符 放 在 新 行 之 首 , 划 分 出 的 新 行 要 进 行 适 当 的 缩 进 , 使 排 版 整 齐 , 语 句 可 读 ⃞
示 例 :
perm_count_msg.head.len = NO7_TO_STAT_PERM_COUNT_LEN
+ STAT_SIZE_PER_FRAM * sizeof( _UL );
act_task_table[frame_id * STAT_TASK_CHECK_NUMBER + index].occupied
= stat_poi[index].occupied;
act_task_table[taskno].duration_true_or_false
= SYS_get_sccp_statistic_state( stat_item );
report_or_not_flag = ((taskno < MAX_ACT_TASK_NUMBER)
仅 供 内 部 使 用 2

软 件 编 程 规 范 总 则
1 排 版
&& (n7stat_stat_item_valid (stat_item))
&& (act_task_table[taskno].result_data != 0));
仅 供 内 部 使 用 3

软 件 编 程 规 范 总 则
1 排 版
¹1-4: 循 环 、 判 断 等 语 句 中 若 有 较 长 的 表 达 式 或 语 句 , 则 要 进 行 适 应 的 划 分 , 长 表 达 式 要 在 低
优 先 级 操 作 符 处 划 分 新 行 , 操 作 符 放 在 新 行 之 首 ⃞
示 例 :
if ((taskno < max_act_task_number)
&& (n7stat_stat_item_valid (stat_item)))
{
... // program code
}
for (i = 0, j = 0; (i < BufferKeyword[word_index].word_length)
&& (j < NewKeyword.word_length); i++, j++)
{
... // program code
}
for (i = 0, j = 0;
(i < first_word_length) && (j < second_word_length);
i++, j++)
{
... // program code
}
¹1-5: 若 函 数 或 过 程 中 的 参 数 较 长 , 则 要 进 行 适 当 的 划 分 ⃞
示 例 :
n7stat_str_compare((BYTE *) & stat_object,
(BYTE *) & (act_task_table[taskno].stat_object),
sizeof (_STAT_OBJECT));
n7stat_flash_act_duration( stat_item, frame_id *STAT_TASK_CHECK_NUMBER
+ index, stat_object );
¹1-6: 不 允 许 把 多 个 短 语 句 写 在 一 行 中 , 即 一 行 只 写 一 条 语 句 ⃞
示 例 : 如如 下 例 子 不 符 合 规 范 ⃞
rect.length = 0; rect.width = 0;
应 如如 下 书 写
仅 供 内 部 使 用 4

软 件 编 程 规 范 总 则
1 排 版
rect.length = 0;
rect.width = 0;
¹1-7:if、for、do、while、case、switch、default 等 语 句 自 占 一 行 , 且 if、for、
do、while 等 语 句 的 执 行 语 句 部 分 无 论 多 少 都 要 加 括 号 {}⃞
示 例 : 如如 下 例 子 不 符 合 规 范 ⃞
if (pUserCR == NULL) return;
应 如如 下 书 写 :
if (pUserCR == NULL)
{
return;
}
¹1-8: 对 齐 只 使 用 空 格 键 , 不 使 用 TAB 键 ⃞
说 明 : 以 免 用 不 同 的 编 辑 器 阅 读 程 序 时 , 因 TAB 键 所 设 置 的 空 格 数 目 不 同 而 造 成 程 序 布 局
不 整 齐 , 不 要 使 用 BC 作 为 编 辑 器 合 版 本 , 因 为 BC 会 自 动 将 8 个 空 格 变 为 一 个 TAB 键 ,
因 此 使 用 BC 合 入 的 版 本 大 多 会 将 缩 进 变 乱 ⃞
¹1-9: 函 数 或 过 程 的 开 始始 、 结 构 的 定 义 及 循 环 、 判 断 等 语 句 中 的 代 码 都 要 采 用 缩 进 风 格 ,case
语 句 下 的 情 况 处 理 语 句 也 要 遵 从 语 句 缩 进 要 求 ⃞
¹1-10: 程 序 块 的 分 界 符 ( 如如 C/C++ 语 言 的 大 括 号 ‘{’ 和和 ‘}’) 应 各 独 占 一 行 并 且 位 于 同 一
列 , 同 时 与 引 用 它 们 的 语 句 左 对 齐 ⃞ 在 函 数 体 的 开 始始 、 类 的 定 义 、 结 构 的 定 义 、 枚 举 的 定 义 以
及 if、for、do、while、switch、case 语 句 中 的 程 序 都 要 采 用 如如 上 的 缩 进 方 式 ⃞
示 例 : 如如 下 例 子 不 符 合 规 范 ⃞
for (...) {
... // program code
}
if (...)
{
... // program code
}
仅 供 内 部 使 用 5

软 件 编 程 规 范 总 则
1 排 版
void example_fun( void )
{
... // program code
}
应 如如 下 书 写 ⃞
for (...)
{
... // program code
}
if (...)
{
... // program code
}
void example_fun( void )
{
... // program code
}
¹1-11: 在 两 个 以 上 的 关 键 字 、 变 量 、 常 量 进 行 对 等 操 作 时 , 它 们 之 间 的 操 作 符 之 前前 、 之 后 或
者 前前 后 要 加 空 格 ; 进 行 非 对 等 操 作 时 , 如如 果 是 关 系 密 切 的 立 即 操 作 符 ( 如如 ->),
后 不 应 加 空
格 ⃞
说 明 : 采 用 这 种 松 散 方 式 编 写 代 码 的 目 的 是 使 代 码 更 加 清 晰 ⃞
由 于 留 空 格 所 产 生 的 清 晰 性 是 相 对 的 , 所 以 , 在 已 经 非 常 清 晰 的 语 句 中 没 有 必 要 再 留 空 格 ,
如如 果 语 句 已 足 够 清 晰 则 括 号 内 侧 ( 即 左 括 号 后 面 和和 右 括 号 前前 面 ) 不 需 要 加 空 格 , 多 重 括 号 间
不 必 加 空 格 , 因 为 在 C/C++ 语 言 中 括 号 已 经 是 最 清 晰 的 标 志 了 ⃞
在 长 语 句 中 , 如如 果 需 要 加 的 空 格 非 常 多 , 那 么 应 该 保 持 整 体 清 晰 , 而 在 局 部 不 加 空 格 ⃞ 给
操 作 符 留 空 格 时 不 要 连 续 留 两 个 以 上 空 格 ⃞
示 例 :
(1) 逗 号 、 分 号 只 在 后 面 加 空 格 ⃞
int a, b, c;
仅 供 内 部 使 用 6

软 件 编 程 规 范 总 则
1 排 版
(2) 比 较 操 作 符 , 赋 值 操 作 符 "="、 "+=", 算 术 操 作 符 "+"、"%", 逻 辑 操 作 符 "&&"、
"&", 位 域 操 作 符 ""、"." 前前 后 不 加 空 格 ⃞
p->id = pid;
// "->" 指 针 前前 后 不 加 空 格
(5) if、for、while、switch 等 与 后 面 的 括 号 间 应 加 空 格 , 使 if 等 关 键 字 更 为 突 出 、
明 显 ⃞
if (a >= b && c > d)
½1-1: 一 行 程 序 以 小 于 80 字 符 为 宜 , 不 要 写 得 过 长 ⃞
仅 供 内 部 使 用 7

软 件 编 程 规 范 总 则
2 注 释
2 注 释
¹2-1: 一 般 情 况 下 , 源 程 序 有 效 注 释 量 必 须 在 20% 以 上 ⃞
说 明 : 注 释 的 原 则 是 有 助 于 对 程 序 的 阅 读 理 解 , 在 该 加 的 地 方 都 加 了 , 注 释 不 宜 太 多 也 不
能 太 少 , 注 释 语 言 必 须 准 确 、 易 懂 、 简 洁 ⃞
¹2-2: 说 明 性 文 件 ( 如如 头头 文 件 .h 文 件 、.inc 文 件 、.def 文 件 、 编 译 说 明 文 件 .cfg 等 ) 头头 部 应
进 行 注 释 , 注 释 必 须 列 出 : 版 权 说 明 、 版 本 号 、 生 成 日 期 、 作 者 、 内 容 、 功 能 、 与 其 它 文 件 的
关 系 、 修 改 日 志 等 , 头头 文 件 的 注 释 中 还 应 有 函 数 功 能 简 要 说 明 ⃞
示 例 : 下 面 这 段 头头 文 件 的 头头 注 释 比 较 标 准 , 当 然 , 并 不 局 限 于 此 格 式 , 但 上 述 信 息 建 议 要
包包 含 在 内 ⃞
/*************************************************
Copyright (C), 1988-1999, Huawei Tech. Co., Ltd.
File name: // 文 件 名
Author: Version: Date: // 作 者 、 版 本 及 完 成 日 期
Description:
// 用 于 详 细 说 明 此 程 序 文 件 完 成 的 主 要 功 能 , 与 其 他 模 块
// 或 函 数 的 接 口 , 输 出 值 、 取 值 范 围 、 含 义 及 参 数 间 的 控
// 制制 、 顺 序 、 独 立 或 依 赖 等 关 系
Others:
// 其 它 内 容 的 说 明
Function List: // 主 要 函 数 列 表 , 每 条 记 录 应 包包 括 函 数 名 及 功 能 简 要 说 明
1. ....
History: // 修 改 历 史 记 录 列 表 , 每 条 修 改 记 录 应 包包 括 修 改 日 期 、 修 改
// 者 及 修 改 内 容 简 述
1. Date:
Author:
Modification:
2. ...
*************************************************/
¹2-3: 源 文 件 头头 部 应 进 行 注 释 , 列 出 : 版 权 说 明 、 版 本 号 、 生 成 日 期 、 作 者 、 模 块 目 的 / 功 能 、
主 要 函 数 及 其 功 能 、 修 改 日 志 等 ⃞
示 例 : 下 面 这 段 源 文 件 的 头头 注 释 比 较 标 准 , 当 然 , 并 不 局 限 于 此 格 式 , 但 上 述 信 息 建 议 要
包包 含 在 内 ⃞
仅 供 内 部 使 用 8

软 件 编 程 规 范 总 则
2 注 释
/************************************************************
Copyright (C), 1988-1999, Huawei Tech. Co., Ltd.
FileName: test.cpp
Author: Version : Date:
Description: // 模 块 描 述
Version:
// 版 本 信 息
Function List: // 主 要 函 数 及 其 功 能
1. -------
History: // 历 史 修 改 记 录
David 96/10/12 1.0 build this moudle
***********************************************************/
说 明 :Description 一 项 描 述 本 文 件 的 内 容 、 功 能 、 内 部 各 部 分 之 间 的 关 系 及 本 文 件 与
其 它 文 件 关 系 等 ⃞History 是 修 改 历 史 记 录 列 表 , 每 条 修 改 记 录 应 包包 括 修 改 日 期 、 修 改
者 及 修 改 内 容 简 述 ⃞
¹2-4: 函 数 头头 部 应 进 行 注 释 , 列 出 : 函 数 的 目 的 / 功 能 、 输 入 参 数 、 输 出 参 数 、 返 回 值 、 调 用
关 系 ( 函 数 、 表 ) 等 ⃞
示 例 : 下 面 这 段 函 数 的 注 释 比 较 标 准 , 当 然 , 并 不 局 限 于 此 格 式 , 但 上 述 信 息 建 议 要 包包 含
在 内 ⃞
/*************************************************
Function: // 函 数 名 称
Description:
Calls:
Called By:
// 函 数 功 能 、 性 能 等 的 描 述
// 被 本 函 数 调 用 的 函 数 清 单
// 调 用 本 函 数 的 函 数 清 单
Table Accessed: // 被 访 问 的 表 ( 此 项 仅 对 于 牵 扯 到到 数 据 库 操 作 的 程 序 )
Table Updated: // 被 修 改 的 表 ( 此 项 仅 对 于 牵 扯 到到 数 据 库 操 作 的 程 序 )
Input:
// 输 入 参 数 说 明 , 包包 括 每 个 参 数 的 作
// 用 、 取 值 说 明 及 参 数 间 关 系 ⃞
Output:
Return:
// 对 输 出 参 数 的 说 明 ⃞
// 函 数 返 回 值 的 说 明
Others:
// 其 它 说 明
*************************************************/
仅 供 内 部 使 用 9

软 件 编 程 规 范 总 则
2 注 释
¹2-5: 边 写 代 码 边 注 释 , 修 改 代 码 同 时 修 改 相 应 的 注 释 , 以 保 证 注 释 与 代 码 的 一 致 性 ⃞ 不 再 有
用 的 注 释 要 删 除 ⃞
¹2-6: 注 释 的 内 容 要 清 楚 、 明 了 , 含 义 准 确 , 防 止 注 释 二 义 性 ⃞
说 明 : 错 误 的 注 释 不 但 无 益 反 而 有 害 ⃞
规 则 2-7: 避 免 在 注 释 中 使 用 缩 写 , 特 别 是 非 常 用 缩 写 ⃞
说 明 : 在 使 用 缩 写 时 或 之 前前 , 应 对 缩 写 进 行 必 要 的 说 明 ⃞
¹2-8: 注 释 应 与 其 描 述 的 代 码 相 近 , 对 代 码 的 注 释 应 放 在 其 上 方 或 右 方 ( 对 单 条 语 句 的 注 释 )
相 邻 位 置 , 不 可 放 在 下 面 , 如如 放 于 上 方 则 需 与 其 上 面 的 代 码 用 空 行 隔 开 ⃞
示 例 : 如如 下 例 子 不 符 合 规 范 ⃞
例 1:
/* get replicate sub system index and net indicator */
repssn_ind = ssn_data[index].repssn_index;
repssn_ni = ssn_data[index].ni;
例 2:
repssn_ind = ssn_data[index].repssn_index;
repssn_ni = ssn_data[index].ni;
/* get replicate sub system index and net indicator */
应 如如 下 书 写
/* get replicate sub system index and net indicator */
repssn_ind = ssn_data[index].repssn_index;
repssn_ni = ssn_data[index].ni;
¹2-9: 对 于 所 有 有 物 理 含 义 的 变 量 、 常 量 , 如如 果 其 命命 名 不 是 充 分 自 注 释 的 , 在 声 明 时 都 必 须 加
以 注 释 , 说 明 其 物 理 含 义 ⃞ 变 量 、 常 量 、 宏 的 注 释 应 放 在 其 上 方 相 邻 位 置 或 右 方 ⃞
示 例 :
/* active statistic task number */
#define MAX_ACT_TASK_NUMBER 1000
仅 供 内 部 使 用 10

软 件 编 程 规 范 总 则
2 注 释
#define MAX_ACT_TASK_NUMBER 1000 /* active statistic task number */
¹2-10: 数 据 结 构 声 明 ( 包包 括 数 组 、 结 构 、 类 、 枚 举 等 ), 如如 果 其 命命 名 不 是 充 分 自 注 释 的 , 必 须
加 以 注 释 ⃞ 对 数 据 结 构 的 注 释 应 放 在 其 上 方 相 邻 位 置 , 不 可 放 在 下 面 ; 对 结 构 中 的 每 个 域 的 注
释 放 在 此 域 的 右 方 ⃞
示 例 : 可 按 如如 下 形 式 说 明 枚 举 / 数 据 / 联 合 结 构 ⃞
/* sccp interface with sccp user primitive message name */
enum SCCP_USER_PRIMITIVE
{
N_UNITDATA_IND, /* sccp notify sccp user unit data come */
N_NOTICE_IND, /* sccp notify user the No.7 network can not */
/* transmission this message */
N_UNITDATA_REQ, /* sccp user's unit data transmission request*/
};
¹2-11: 全 局 变 量 要 有 较 详 细 的 注 释 , 包包 括 对 其 功 能 、 取 值 范 围 、 哪哪 些 函 数 或 过 程 存 取 它 以 及
存 取 时 注 意 事 项 等 的 说 明 ⃞
示 例 :
/* The ErrorCode when SCCP translate */
/* Global Title failure, as follows */ // 变 量 作 用 、 含 义
/* 0 - SUCCESS 1 - GT Table error */
/* 2 - GT error Others - no use */ // 变 量 取 值 范 围
/* only function SCCPTranslate() in */
/* this modual can modify it, and other */
/* module can visit it through call */
/* the function GetGTTransErrorCode() */ // 使 用 方 法
BYTE g_GTTranErrorCode;
¹2-12: 注 释 与 所 描 述 内 容 进 行 同 样 的 缩 排 ⃞
说 明 : 可 使 程 序 排 版 整 齐 , 并 方 便 注 释 的 阅 读 与 理 解 ⃞
示 例 : 如如 下 例 子 , 排 版 不 整 齐 , 阅 读 稍 感 不 方 便 ⃞
void example_fun( void )
{
/* code one comments */
CodeBlock One
仅 供 内 部 使 用 11

软 件 编 程 规 范 总 则
2 注 释
}
/* code two comments */
CodeBlock Two
应 改 为 如如 下 布 局 ⃞
void example_fun( void )
{
/* code one comments */
CodeBlock One
}
/* code two comments */
CodeBlock Two
¹2-13: 将 注 释 与 其 上 面 的 代 码 用 空 行 隔 开 ⃞
示 例 : 如如 下 例 子 , 显 得 代 码 过 于 紧 凑 ⃞
/* code one comments */
program code one
/* code two comments */
program code two
应 如如 下 书 写
/* code one comments */
program code one
/* code two comments */
program code two
¹2-14: 对 变 量 的 定 义 和和 分 支 语 句 ( 条 件 分 支 、 循 环 语 句 等 ) 必 须 编 写 注 释 ⃞
说 明 : 这 些 语 句 往 往 是 程 序 实 现 某 一 特 定 功 能 的 关 键 , 对 于 维 护 人 员员 来 说 , 良 好好 的 注 释 帮
助 更 好好 的 理 解 程 序 , 有 时 甚 至 优 于 看 设 计 文 档 ⃞
¹2-15: 对 于 switch 语 句 下 的 case 语 句 , 如如 果 因 为 特 殊 情 况 需 要 处 理 完 一 个 case 后 进 入 下 一
个 case 处 理 , 必 须 在 该 case 语 句 处 理 完 、 下 一 个 case 语 句 前前 加 上 明 确 的 注 释 ⃞
说 明 : 这 样 比 较 清 楚 程 序 编 写 者 的 意 图 , 有 效 防 止 无 故 遗 漏 break 语 句 ⃞
仅 供 内 部 使 用 12

软 件 编 程 规 范 总 则
2 注 释
示 例 ( 注 意 斜 体 加 粗 部 分 ):
case CMD_UP:
ProcessUp();
break;
case CMD_DOWN:
ProcessDown();
break;
case CMD_FWD:
ProcessFwd();
if (...)
{
...
break;
}
else
{
ProcessCFW_B();
}
// now jump into case CMD_A
case CMD_A:
ProcessA();
break;
case CMD_B:
ProcessB();
break;
case CMD_C:
ProcessC();
break;
case CMD_D:
ProcessD();
仅 供 内 部 使 用 13

软 件 编 程 规 范 总 则
2 注 释
break;
...
½2-1: 避 免 在 一 行 代 码 或 表 达 式 的 中 间 插 入 注 释 ⃞
说 明 : 除 非 必 要 , 不 应 在 代 码 或 表 达 中 间 插 入 注 释 , 否 则 容 易 使 代 码 可 理 解 性 变 差 ⃞
½2-2: 通 过 对 函 数 或 过 程 、 变 量 、 结 构 等 正 确 的 命命 名 以 及 合 理 地 组 织 代 码 的 结 构 , 使 代 码 成 为
自 注 释 的 ⃞
说 明 : 清 晰 准 确 的 函 数 、 变 量 等 的 命命 名 , 可 增 加 代 码 可 读 性 , 并 减 少 不 必 要 的 注 释 ⃞
½2-3: 在 代 码 的 功 能 、 意 图 层 次 上 进 行 注 释 , 提 供 有 用 、 额 外 的 信 息 ⃞
说 明 : 注 释 的 目 的 是 解 释 代 码 的 目 的 、 功 能 和和 采 用 的 方 法 , 提 供 代 码 以 外 的 信 息 , 帮 助 读
者 理 解 代 码 , 防 止 没 必 要 的 重 复 注 释 信 息 ⃞
示 例 : 如如 下 注 释 意 义 不 大 ⃞
/* if receive_flag is TRUE */
if (receive_flag)
而 如如 下 的 注 释 则 给 出 了 额 外 有 用 的 信 息 ⃞
/* if mtp receive a message from links */
if (receive_flag)
½2-4: 在 程 序 块 的 结 束 行 右 方 加 注 释 标 记 , 以 表 明 某 程 序 块 的 结 束 ⃞
说 明 : 当 代 码 段 较 长 , 特 别 是 多 重 嵌 套套 时 , 这 样 做 可 以 使 代 码 更 清 晰 , 更 便 于 阅 读 ⃞
示 例 : 参 见 如如 下 例 子 ⃞
if (...)
{
// program code
while (index < MAX_INDEX)
{
// program code
} /* end of while (index < MAX_INDEX) */ // 指 明 该 条 while 语 句 结
束
} /* end of if (...)*/ // 指 明 是 哪哪 条 if 语 句 结 束
仅 供 内 部 使 用 14

软 件 编 程 规 范 总 则
2 注 释
½2-5: 注 释 格 式 尽 量 统 一 , 建 议 使 用 ‚/* …“…“ */‛⃞
½2-6: 注 释 应 考 虑 程 序 易 读 及 外 观 排 版 的 因 素 , 使 用 的 语 言 若 是 中 、 英 兼 有 的 , 建 议 多 使 用 中
文 , 除 非 能 用 非 常 流 利 准 确 的 英 文 表 达 ⃞
说 明 : 注 释 语 言 不 统 一 , 影 响响 程 序 易 读 性 和和 外 观 排 版 , 出 于 对 维 护 人 员员 的 考 虑 , 建 议 使 用
中 文 ⃞
仅 供 内 部 使 用 15

软 件 编 程 规 范 总 则
3 标 志 符 命命 名
3 标 识 符 命命 名
¹3-1: 标 识 符 的 命命 名 要 清 晰 、 明 了 , 有 明 确 含 义 , 同 时 使 用 完 整 的 单 词 或 大 家 基 本 可 以 理 解 的
缩 写 , 避 免 使 人 产 生 误 解 ⃞
说 明 : 较 短 的 单 词 可 通 过 去 掉 ‚ 元 音 ‛ 形 成 缩 写 ; 较 长 的 单 词 可 取 单 词 的 头头 几 个 字 母 形 成
缩 写 ; 一 些 单 词 有 大 家 公 认 的 缩 写 ⃞
示 例 : 如如 下 单 词 的 缩 写 能 够 被 大 家 基 本 认 可 ⃞
temp 可 缩 写 为 tmp ;
flag 可 缩 写 为 flg ;
statistic 可 缩 写 为 stat ;
increment 可 缩 写 为 inc ;
message 可 缩 写 为 msg ;
¹3-2: 命命 名 中 若 使 用 特 殊 约 定 或 缩 写 , 则 要 有 注 释 说 明 ⃞
说 明 : 应 该 在 源 文 件 的 开 始始 之 处 , 对 文 件 中 所 使 用 的 缩 写 或 约 定 , 特 别 是 特 殊 的 缩 写 , 进
行 必 要 的 注 释 说 明 ⃞
¹3-3: 自 己 特 有 的 命命 名 风 格 , 要 自 始始 至 终 保 持 一 致 , 不 可 来 回 变 化化 ⃞
说 明 : 个 人 的 命命 名 风 格 , 在 符 合 所 在 项 目 组 或 产 品品 组 的 命命 名 规 则 的 前前 提 下 , 才 可 使 用 ⃞( 即
命命 名 规 则 中 没 有 规 定 到到 的 地 方 才 可 有 个 人 命命 名 风 格 )⃞
¹3-4: 对 于 变 量 命命 名 , 禁 止 取 单 个 字 符 ( 如如 i、j、k...),
建 议 除 了 要 有 具 体 含 义 外 , 还 能
表 明 其 变 量 类 型 、 数 据 类 型 等 , 但 i、j、k 作 局 部 循 环 变 量 是 允 许 的 ⃞
说 明 : 变 量 , 尤 其 是 局 部 变 量 , 如如 果 用 单 个 字 符 表 示 , 很 容 易 敲 错 ( 如如 i 写 成 j), 而 编
译 时 又 检 查 不 出 来 , 有 可 能 为 了 这 个 小 小 的 错 误 而 花 费 大 量 的 查 错 时 间 ⃞
示 例 : 下 面 所 示 的 局 部 变 量 名 的 定 义 方 法 可 以 借 鉴 ⃞
int liv_Width
其 变 量 名 解 释 如如 下 :
l 局 部 变 量 (Local) ( 其 它 :g 全 局 变 量 (Global)...)
i
数 据 类 型 (Interger)
v 变 量 (Variable) ( 其 它 :c 常 量 (Const)...)
Width 变 量 含 义
仅 供 内 部 使 用 16

软 件 编 程 规 范 总 则
3 标 志 符 命命 名
这 样 可 以 防 止 局 部 变 量 与 全 局 变 量 重 名 ⃞
¹3-5: 命命 名 规 范 必 须 与 所 使 用 的 系 统 风 格 保 持 一 致 , 并 在 同 一 项 目 中 统 一 , 比 如如 采 用 UNIX 的
全 小 写 加 下 划 线 的 风 格 或 大 小 写 混 排 的 方 式 , 不 要 使 用 大 小 写 与 下 划 线 混 排 的 方 式 , 用 作 特 殊
标 识 如如 标 识 成 员员 变 量 或 全 局 变 量 的 m_ 和和 g_, 其 后 加 上 大 小 写 混 排 的 方 式 是 允 许 的 ⃞
示 例 : Add_User 不 允 许 ,add_user、AddUser、m_AddUser 允 许 ⃞
½3-1: 除 非 必 要 , 不 要 用 数 字 或 较 奇奇 怪 的 字 符 来 定 义 标 识 符 ⃞
示 例 : 如如 下 命命 名 , 使 人 产 生 疑 惑 ⃞
#define _EXAMPLE_0_TEST_
#define _EXAMPLE_1_TEST_
void set_sls00( BYTE sls );
应 改 为 有 意 义 的 单 词 命命 名
#define _EXAMPLE_UNIT_TEST_
#define _EXAMPLE_ASSERT_TEST_
void set_udt_msg_sls( BYTE sls );
½3-2: 在 同 一 软 件 产 品品 内 , 应 规 划 好好 接 口 部 分 标 识 符 ( 变 量 、 结 构 、 函 数 及 常 量 ) 的 命命 名 , 防
止 编 译 、 链 接 时 产 生 冲 突 ⃞
说 明 : 对 接 口 部 分 的 标 识 符 应 该 有 更 严 格 限 制制 , 防 止 冲 突 ⃞ 如如 可 规 定 接 口 部 分 的 变 量 与 常
量 之 前前 加 上 ‚ 模 块 ‛ 标 识 等 ⃞
½3-3: 用 正 确 的 反 义 词 组 命命 名 具 有 互 斥 意 义 的 变 量 或 相 反 动 作 的 函 数 等 ⃞
说 明 : 下 面 是 一 些 在 软 件 中 常 用 的 反 义 词 组 ⃞
add / remove begin / end create / destroy
insert / delete first / last get / release
increment / decrement
put / get
add / delete lock / unlock open / close
min / max old / new start / stop
next / previous source / target show / hide
send / receive source / destination
cut / paste up / down
示 例 :
int min_sum;
仅 供 内 部 使 用 17

软 件 编 程 规 范 总 则
3 标 志 符 命命 名
int max_sum;
int add_user( BYTE *user_name );
int delete_user( BYTE *user_name );
½3-4: 除 了 编 译 开 关 / 头头 文 件 等 特 殊 应 用 , 应 避 免 使 用 _EXAMPLE_TEST_ 之 类 以 下 划 线 开 始始 和和
结 尾 的 定 义 ⃞
仅 供 内 部 使 用 18

软 件 编 程 规 范 总 则
4 可 读 性
4 可 读 性
¹4-1: 注 意 运 算 符 的 优 先 级 , 并 用 括 号 明 确 表 达 式 的 操 作 顺 序 , 避 免 使 用 默 认 优 先 级 ⃞
说 明 : 防 止 阅 读 程 序 时 产 生 误 解 , 防 止 因 默 认 的 优 先 级 与 设 计 思 想 不 符 而 导 致 程 序 出 错 ⃞
示 例 : 下 列 语 句 中 的 表 达 式
word = (high

软 件 编 程 规 范 总 则
4 可 读 性
}
... // program code
½4-1: 源 程 序 中 关 系 较 为 紧 密 的 代 码 应 尽 可 能 相 邻 ⃞
说 明 : 便 于 程 序 阅 读 和和 查 找 ⃞
示 例 : 以 下 代 码 布 局 不 太 合 理 ⃞
rect.length = 10;
char_poi = str;
rect.width = 5;
若 按 如如 下 形 式 书 写 , 可 能 更 清 晰 一 些 ⃞
rect.length = 10;
rect.width = 5; // 矩 形 的 长 与 宽 关 系 较 密 切 , 放 在 一 起 ⃞
char_poi = str;
½4-2: 不 要 使 用 难 懂 的 技 巧 性 很 高 的 语 句 , 除 非 很 有 必 要 时 ⃞
说 明 : 高 技 巧 语 句 不 等 于 高 效 率 的 程 序 , 实 际 上 程 序 的 效 率 关 键 在 于 算 法 ⃞
示 例 : 如如 下 表 达 式 , 考 虑 不 周周 就 可 能 出 问 题 , 也 较 难 理 解 ⃞
* stat_poi ++ += 1;
* ++ stat_poi += 1;
应 分 别 改 为 如如 下 ⃞
*stat_poi += 1;
stat_poi++; // 此 二 语 句 功 能 相 当 于 ‚ * stat_poi ++ += 1; ‛
++ stat_poi;
*stat_poi += 1; // 此 二 语 句 功 能 相 当 于 ‚ * ++ stat_poi += 1; ‛
仅 供 内 部 使 用 20

软 件 编 程 规 范 总 则
5 变 量 、 结 构
5 变 量 、 结 构
¹5-1: 去 掉 没 必 要 的 公 共 变 量 ⃞
说 明 : 公 共 变 量 是 增 大 模 块 间 耦 合 的 原 因 之 一 , 故 应 减 少 没 必 要 的 公 共 变 量 以 降 低 模 块 间
的 耦 合 度 ⃞
¹5-2: 仔 细 定 义 并 明 确 公 共 变 量 的 含 义 、 作 用 、 取 值 范 围 及 公 共 变 量 间 的 关 系 ⃞
说 明 : 在 对 变 量 声 明 的 同 时 , 应 对 其 含 义 、 作 用 及 取 值 范 围 进 行 注 释 说 明 , 同 时 若 有 必 要
还 应 说 明 与 其 它 变 量 的 关 系 ⃞
¹5-3: 明 确 公 共 变 量 与 操 作 此 公 共 变 量 的 函 数 或 过 程 的 关 系 , 如如 访 问 、 修 改 及 创 建 等 ⃞
说 明 : 明 确 过 程 操 作 变 量 的 关 系 后 , 将 有 利 于 程 序 的 进 一 步 优 化化 、 单 元 测 试 、 系 统 联 调 以
及 代 码 维 护 等 ⃞ 这 种 关 系 的 说 明 可 在 注 释 或 文 档 中 描 述 ⃞
示 例 : 在 源 文 件 中 , 可 按 如如 下 注 释 形 式 说 明 ⃞
RELATION System_Init Input_Rec Print_Rec Stat_Score
Student Create Modify Access Access
Score Create Modify Access Access, Modify
注 :RELATION 为 操 作 关 系 ;System_Init、Input_Rec、Print_Rec、Stat_Score
为 四 个 不 同 的 函 数 ;Student、Score 为 两 个 全 局 变 量 ;Create 表 示 创 建 ,Modify 表
示 修 改 ,Access 表 示 访 问 ⃞
其 中 , 函 数 Input_Rec、Stat_Score 都 可 修 改 变 量 Score, 故 此 变 量 将 引 起 函 数 间 较
大 的 耦 合 , 并 可 能 增 加 代 码 测 试 、 维 护 的 难 度 ⃞
¹5-4: 当 向 公 共 变 量 传 递 数 据 时 , 要 十 分 小 心 , 防 止 赋 与 不 合 理 的 值 或 越 界 等 现 象 发 生 ⃞
说 明 : 对 公 共 变 量 赋 值 时 , 若 有 必 要 应 进 行 合 法 性 检 查 , 以 提 高 代 码 的 可 靠 性 、 稳 定 性 ⃞
¹5-5: 防 止 局 部 变 量 与 公 共 变 量 同 名 ⃞
说 明 : 若 使 用 了 较 好好 的 命命 名 规 则 , 那 么 此 问 题 可 自 动 消 除 ⃞
¹5-6: 严 禁 使 用 未 经 初 始始 化化 的 变 量 作 为 右 值 ⃞
说 明 : 特 别 是 在 C/C++ 中 引 用 未 经 赋 值 的 指 针 , 经 常 会 引 起 系 统 崩 溃 ⃞
仅 供 内 部 使 用 21

软 件 编 程 规 范 总 则
5 变 量 、 结 构
½5-1: 构 造 仅 有 一 个 模 块 或 函 数 可 以 修 改 、 创 建 , 而 其 余 有 关 模 块 或 函 数 只 访 问 的 公 共 变 量 ,
防 止 多 个 不 同 模 块 或 函 数 都 可 以 修 改 、 创 建 同 一 公 共 变 量 的 现 象 ⃞
说 明 : 降 低 公 共 变 量 耦 合 度 ⃞
½5-2: 使 用 严 格 形 式 定 义 的 、 可 移 植 的 数 据 类 型 , 尽 量 不 要 使 用 与 具 体 硬 件 或 软 件 环 境 关 系 密
切 的 变 量 ⃞
说 明 : 使 用 标 准 的 数 据 类 型 , 有 利 于 程 序 的 移 植 ⃞
示 例 : 如如 下 例 子 ( 在 DOS 下 BC3.1 环 境 中 ), 在 移 植 时 可 能 产 生 问 题 ⃞
void main()
{
register int index; // 寄 存 器 变 量
}
_AX = 0x4000; // _AX 是 BC3.1 提 供 的 寄 存 器 ‚ 伪 变 量 ‛
... // program code
½5-3: 结 构 的 功 能 要 单 一 , 是 针 对 一 种 事 务 的 抽 象 ⃞
说 明 : 设 计 结 构 时 应 力力 争 使 结 构 代 表 一 种 现 实 事 务 的 抽 象 , 而 不 是 同 时 代 表 多 种 ⃞ 结 构 中
的 各 元 素 应 代 表 同 一 事 务 的 不 同 侧 面 , 而 不 应 把 描 述 没 有 关 系 或 关 系 很 弱 的 不 同 事 务 的 元
素 放 到到 同 一 结 构 中 ⃞
示 例 : 如如 下 结 构 不 太 清 晰 、 合 理 ⃞
typedef struct STUDENT_STRU
{
unsigned char name[8]; /* student's name */
unsigned char age; /* student's age */
unsigned char sex; /* student's sex, as follows */
/* 0 - FEMALE; 1 - MALE */
unsigned char
teacher_name[8]; /* the student teacher's name */
unisgned char
teacher_sex; /* his teacher sex */
} STUDENT;
若 改 为 如如 下 , 可 能 更 合 理 些 ⃞
仅 供 内 部 使 用 22

软 件 编 程 规 范 总 则
5 变 量 、 结 构
typedef struct TEACHER_STRU
{
unsigned char name[8]; /* teacher name */
unisgned char sex; /* teacher sex, as follows */
/* 0 - FEMALE; 1 - MALE */
} TEACHER;
typedef struct STUDENT_STRU
{
unsigned char name[8]; /* student's name */
unsigned char age; /* student's age */
unsigned char sex; /* student's sex, as follows */
/* 0 - FEMALE; 1 - MALE */
unsigned int teacher_ind; /* his teacher index */
} STUDENT;
½5-4: 不 要 设 计 面 面 俱 到到 、 非 常 灵 活 的 数 据 结 构 ⃞
说 明 : 面 面 俱 到到 、 灵 活 的 数 据 结 构 反 而 容 易 引 起 误 解 和和 操 作 困 难 ⃞
½5-5: 不 同 结 构 间 的 关 系 不 要 过 于 复 杂 ⃞
说 明 : 若 两 个 结 构 间 关 系 较 复 杂 、 密 切 , 那 么 应 合 为 一 个 结 构 ⃞
示 例 : 如如 下 两 个 结 构 的 构 造 不 合 理 ⃞
typedef struct PERSON_ONE_STRU
{
unsigned char name[8];
unsigned char addr[40];
unsigned char sex;
unsigned char city[15];
} PERSON_ONE;
typedef struct PERSON_TWO_STRU
{
unsigned char name[8];
unsigned char age;
unsigned char tel;
} PERSON_TWO;
仅 供 内 部 使 用 23

软 件 编 程 规 范 总 则
5 变 量 、 结 构
由 于 两 个 结 构 都 是 描 述 同 一 事 物 的 , 那 么 不 如如 合 成 一 个 结 构 ⃞
typedef struct PERSON_STRU
{
unsigned char name[8];
unsigned char age;
unsigned char sex;
unsigned char addr[40];
unsigned char city[15];
unsigned char tel;
} PERSON;
½5-6: 结 构 中 元 素 的 个 数 应 适 中 ⃞ 若 结 构 中 元 素 个 数 过 多 可 考 虑 依 据 某 种 原 则 把 元 素 组 成 不 同
的 子 结 构 , 以 减 少 原 结 构 中 元 素 的 个 数 ⃞
说 明 : 增 加 结 构 的 可 理 解 性 、 可 操 作 性 和和 可 维 护 性 ⃞
示 例 : 假 如如 认 为 如如 上 的 _PERSON 结 构 元 素 过 多 , 那 么 可 如如 下 对 之 划 分 ⃞
typedef struct PERSON_BASE_INFO_STRU
{
unsigned char name[8];
unsigned char age;
unsigned char sex;
} PERSON_BASE_INFO;
typedef struct PERSON_ADDRESS_STRU
{
unsigned char addr[40];
unsigned char city[15];
unsigned char tel;
} PERSON_ADDRESS;
typedef struct PERSON_STRU
{
PERSON_BASE_INFO person_base;
PERSON_ADDRESS person_addr;
} PERSON;
仅 供 内 部 使 用 24

软 件 编 程 规 范 总 则
5 变 量 、 结 构
½5-7: 仔 细 设 计 结 构 中 元 素 的 布 局 与 排 列 顺 序 , 使 结 构 容 易 理 解 、 节 省 占 用 空 间 , 并 减 少 引 起
误 用 现 象 ⃞
说 明 : 合 理 排 列 结 构 中 元 素 顺 序 , 可 节 省 空 间 并 增 加 可 理 解 性 ⃞
示 例 : 如如 下 结 构 中 的 位 域 排 列 , 将 占 较 大 空 间 , 可 读 性 也 稍 差 ⃞
typedef struct EXAMPLE_STRU
{
unsigned int valid: 1;
PERSON person;
unsigned int set_flg: 1;
} EXAMPLE;
若 改 成 如如 下 形 式 , 不 仅 可 节 省 1 字 节 空 间 , 可 读 性 也 变 好好 了 ⃞
typedef struct EXAMPLE_STRU
{
unsigned int valid: 1;
unsigned int set_flg: 1;
PERSON person ;
} EXAMPLE;
½5-8: 结 构 的 设 计 要 尽 量 考 虑 向 前前 兼 容 和和 以 后 的 版 本 升 级 , 并 为 某 些 未 来 可 能 的 应 用 保 留 余 地
( 如如 预 留 一 些 空 间 等 )⃞
说 明 : 软 件 向 前前 兼 容 的 特 性 , 是 软 件 产 品品 是 否 成 功 的 重 要 标 志 之 一 ⃞ 如如 果 要 想 使 产 品品 具 有
较 好好 的 前前 向 兼 容 , 那 么 在 产 品品 设 计 之 初 就 应 为 以 后 版 本 升 级 保 留 一 定 余 地 , 并 且 在 产 品品 升
级 时 必 须 考 虑 前前 一 版 本 的 各 种 特 性 ⃞
½5-9: 留 心 具 体 语 言 及 编 译 器 处 理 不 同 数 据 类 型 的 原 则 及 有 关 细 节 ⃞
说 明 : 如如 在 C 语 言 中 ,static 局 部 变 量 将 在 内 存 ‚ 数 据 区 ‛ 中 生 成 , 而 非 static 局 部
变 量 将 在 ‚ 堆 栈 ‛ 中 生 成 ⃞ 这 些 细 节 对 程 序 质 量 的 保 证 非 常 重 要 ⃞
½5-10: 编 程 时 , 要 注 意 数 据 类 型 的 强 制制 转 换 ⃞
说 明 : 当 进 行 数 据 类 型 强 制制 转 换 时 , 其 数 据 的 意 义 、 转 换 后 的 取 值 等 都 有 可 能 发 生 变 化化 ,
而 这 些 细 节 若 考 虑 不 周周 , 就 很 有 可 能 留 下 隐 患 ⃞
½5-11: 对 编 译 系 统 默 认 的 数 据 类 型 转 换 , 也 要 有 充 分 的 认 识 ⃞
示 例 : 如如 下 赋 值 , 多 数 编 译 器 不 产 生 告告 警 , 但 值 的 含 义 还 是 稍 有 变 化化 ⃞
仅 供 内 部 使 用 25

软 件 编 程 规 范 总 则
5 变 量 、 结 构
char chr;
unsigned short int exam;
chr = -1;
exam = chr; // 编 译 器 不 产 生 告告 警 , 此 时 exam 为 0xFFFF⃞
½5-12: 尽 量 减 少 没 有 必 要 的 数 据 类 型 默 认 转 换 与 强 制制 转 换 ⃞
½5-13: 合 理 地 设 计 数 据 并 使 用 自 定 义 数 据 类 型 , 避 免 数 据 间 进 行 不 必 要 的 类 型 转 换 ⃞
½5-14: 对 自 定 义 数 据 类 型 进 行 恰 当 命命 名 , 使 它 成 为 自 描 述 性 的 , 以 提 高 代 码 可 读 性 ⃞ 注 意 其
命命 名 方 式 在 同 一 产 品品 中 的 统 一 ⃞
说 明 : 使 用 自 定 义 类 型 , 可 以 弥 补 编 程 语 言 提 供 类 型 少 、 信 息 量 不 足 的 缺 点 , 并 能 使 程 序
清 晰 、 简 洁 ⃞
示 例 : 可 参 考 如如 下 方 式 声 明 自 定 义 数 据 类 型 ⃞
下 面 的 声 明 可 使 数 据 类 型 的 使 用 简 洁 、 明 了 ⃞
typedef unsigned char BYTE;
typedef unsigned short WORD;
typedef unsigned int DWORD;
下 面 的 声 明 可 使 数 据 类 型 具 有 更 丰 富 的 含 义 ⃞
typedef float DISTANCE;
typedef float SCORE;
½5-15: 当 声 明 用 于 分 布 式 环 境 或 不 同 CPU 间 通 信 环 境 的 数 据 结 构 时 , 必 须 考 虑 机 器 的 字 节 顺
序 、 使 用 的 位 域 及 字 节 对 齐 等 问 题 ⃞
说 明 : 比 如如 Intel CPU 与 68360 CPU, 在 处 理 位 域 及 整 数 时 , 其 在 内 存 存 放 的 ‚ 顺 序 ‛
正 好好 相 反 ⃞
示 例 : 假 如如 有 如如 下 短 整 数 及 结 构 ⃞
unsigned short int exam;
typedef struct EXAM_BIT_STRU
{ /* Intel 68360 */
unsigned int A1: 1; /* bit 0 7 */
unsigned int A2: 1; /* bit 1 6 */
仅 供 内 部 使 用 26

软 件 编 程 规 范 总 则
5 变 量 、 结 构
unsigned int A3: 1; /* bit 2 5 */
} EXAM_BIT;
如如 下 是 Intel CPU 生 成 短 整 数 及 位 域 的 方 式 ⃞
内 存 : 0 1 2 ... ( 从 低 到到 高 , 以 字 节 为 单 位 )
exam exam 低 字 节 exam 高 字 节
内 存 : 0 bit 1 bit 2 bit ... ( 字 节 的 各 ‚ 位 ‛)
EXAM_BIT A1 A2 A3
如如 下 是 68360 CPU 生 成 短 整 数 及 位 域 的 方 式 ⃞
内 存 : 0 1 2 ... ( 从 低 到到 高 , 以 字 节 为 单 位 )
exam exam 高 字 节 exam 低 字 节
内 存 : 7 bit 6 bit 5 bit ... ( 字 节 的 各 ‚ 位 ‛)
EXAM_BIT A1 A2 A3
说 明 : 在 对 齐 方 式 下 ,CPU 的 运 行 效 率 要 快 得 多 ⃞
示 例 : 如如 下 图 , 当 一 个 long 型 数 ( 如如 图 中 long1) 在 内 存 中 的 位 置 正 好好 与 内 存 的 字 边 界
对 齐 时 ,CPU 存 取 这 个 数 只 需 访 问 一 次 内 存 , 而 当 一 个 long 型 数 ( 如如 图 中 的 long2) 在
内 存 中 的 位 置 跨 越 了 字 边 界 时 ,CPU 存 取 这 个 数 就 需 要 多 次 访 问 内 存 , 如如 i960cx 访 问 这
样 的 数 需 读 内 存 三 次 ( 一 个 BYTE、 一 个 SHORT、 一 个 BYTE, 由 CPU 的 微 代 码 执 行 , 对
软 件 透 明 ), 所 有 对 齐 方 式 下 CPU 的 运 行 效 率 明 显 快 多 了 ⃞
1 8 16 24 32
------- ------- ------- -------
| long1 | long1 | long1 | long1 |
------- ------- ------- -------
| | | | long2 |
------- ------- ------- --------
| long2 | long2 | long2 | |
------- ------- ------- --------
| ....
仅 供 内 部 使 用 27

软 件 编 程 规 范 总 则
6 函 数 、 过 程
6 函 数 、 过 程
¹6-1: 对 所 调 用 函 数 的 错 误 返 回 码 要 仔 细 、 全 面 地 处 理 ⃞
¹6-2: 明 确 函 数 功 能 , 精 确 ( 而 不 是 近 似 ) 地 实 现 函 数 设 计 ⃞
¹6-3: 编 写 可 重 入 函 数 时 , 应 注 意 局 部 变 量 的 使 用 ( 如如 编 写 C/C++ 语 言 的 可 重 入 函 数 时 , 应 使
用 auto 即 缺 省 态 局 部 变 量 或 寄 存 器 变 量 )⃞
说 明 : 编 写 C/C++ 语 言 的 可 重 入 函 数 时 , 不 应 使 用 static 局 部 变 量 , 否 则 必 须 经 过 特 殊
处 理 , 才 能 使 函 数 具 有 可 重 入 性 ⃞
¹6-4: 编 写 可 重 入 函 数 时 , 若 使 用 全 局 变 量 , 则 应 通 过 关 中 断 、 信 号 量 ( 即 P、V 操 作 ) 等 手 段
对 其 加 以 保 护 ⃞
说 明 : 若 对 所 使 用 的 全 局 变 量 不 加 以 保 护 , 则 此 函 数 就 不 具 有 可 重 入 性 , 即 当 多 个 进 程 调
用 此 函 数 时 , 很 有 可 能 使 有 关 全 局 变 量 变 为 不 可 知 状 态 ⃞
示 例 : 假 设 Exam 是 int 型 全 局 变 量 , 函 数 Squre_Exam 返 回 Exam 平 方 值 ⃞ 那 么 如如 下
函 数 不 具 有 可 重 入 性 ⃞
unsigned int example( int para )
{
unsigned int temp;
Exam = para; // (**)
temp = Square_Exam( );
}
return temp;
此 函 数 若 被 多 个 进 程 调 用 的 话 , 其 结 果 可 能 是 未 知 的 , 因 为 当 (**) 语 句 刚 执 行 完 后 , 另
外 一 个 使 用 本 函 数 的 进 程 可 能 正 好好 被 激 活 , 那 么 当 新 激 活 的 进 程 执 行 到到 此 函 数 时 , 将 使
Exam 赋 与 另 一 个 不 同 的 para 值 , 所 以 当 控 制制 重 新 回 到到 ‚temp = Square_Exam( )‛
后 , 计 算 出 的 temp 很 可 能 不 是 预 想 中 的 结 果 ⃞ 此 函 数 应 如如 下 改 进 ⃞
unsigned int example( int para )
{
unsigned int temp;
仅 供 内 部 使 用 28

软 件 编 程 规 范 总 则
6 函 数 、 过 程
[ 申 请 信 号 量 操 作 ] // 若 申 请 不 到到 ‚ 信 号 量 ‛, 说 明 另 外 的 进 程 正 处 于
Exam = para;
// 给 Exam 赋 值 并 计 算 其 平 方 过 程 中 ( 即 正 在 使 用 此
temp = Square_Exam( ); // 信 号 ), 本 进 程 必 须 等 待 其 释 放 信 号 后 , 才 可 继
[ 释 放 信 号 量 操 作 ] // 续 执 行 ⃞ 若 申 请 到到 信 号 , 则 可 继 续 执 行 , 但 其
// 它 进 程 必 须 等 待 本 进 程 释 放 信 号 量 后 , 才 能 再 使
}
return temp;
// 用 本 信 号 ⃞
¹6-5: 在 同 一 项 目 组 应 明 确 规 定 对 接 口 函 数 参 数 的 合 法 性 检 查 应 由 函 数 的 调 用 者 负 责 还 是 由 接
口 函 数 本 身 负 责 , 缺 省 是 由 函 数 调 用 者 负 责 ⃞
说 明 : 对 于 模 块 间 接 口 函 数 的 参 数 的 合 法 性 检 查 这 一 问 题 , 往 往 有 两 个 极 端 现 象 , 即 : 要
么 是 调 用 者 和和 被 调 用 者 对 参 数 均 不 作 合 法 性 检 查 , 结 果 就 遗 漏 了 合 法 性 检 查 这 一 必 要 的 处
理 过 程 , 造 成 问 题 隐 患 ; 要 么 就 是 调 用 者 和和 被 调 用 者 均 对 参 数 进 行 合 法 性 检 查 , 这 种 情 况
虽 不 会 造 成 问 题 , 但 产 生 了 冗 余 代 码 , 降 低 了 效 率 ⃞
½6-1: 防 止 将 函 数 的 参 数 作 为 工 作 变 量 ⃞
说 明 : 将 函 数 的 参 数 作 为 工 作 变 量 , 有 可 能 错 误 地 改 变 参 数 内 容 , 所 以 很 危 险 ⃞ 对 必 须 改
变 的 参 数 , 最 好好 先 用 局 部 变 量 代 之 , 最 后 再 将 该 局 部 变 量 的 内 容 赋 给 该 参 数 ⃞
示 例 : 下 函 数 的 实 现 不 太 好好 ⃞
void sum_data( unsigned int num, int *data, int *sum )
{
unsigned int count;
}
*sum = 0;
for (count = 0; count < num; count++)
{
*sum += data[count]; // sum 成 了 工 作 变 量 , 不 太 好好 ⃞
}
若 改 为 如如 下 , 则 更 好好 些 ⃞
void sum_data( unsigned int num, int *data, int *sum )
仅 供 内 部 使 用 29

软 件 编 程 规 范 总 则
6 函 数 、 过 程
{
unsigned int count ;
int sum_temp;
sum_temp = 0;
for (count = 0; count < num; count ++)
{
sum_temp += data[count];
}
}
*sum = sum_temp;
½6-2: 函 数 的 规 模 尽 量 限 制制 在 200 行 以 内 ⃞
说 明 : 不 包包 括 注 释 和和 空 格 行 ⃞
½6-3: 一 个 函 数 仅 完 成 一 件 功 能 ⃞
½6-4: 为 简 单 功 能 编 写 函 数 ⃞
说 明 : 虽 然 为 仅 用 一 两 行 就 可 完 成 的 功 能 去 编 函 数 好好 象 没 有 必 要 , 但 用 函 数 可 使 功 能 明 确
化化 , 增 加 程 序 可 读 性 , 亦 可 方 便 维 护 、 测 试 ⃞
示 例 : 如如 下 语 句 的 功 能 不 很 明 显 ⃞
value = ( a > b ) a : b ;
改 为 如如 下 就 很 清 晰 了 ⃞
int max (int a, int b)
{
return ((a > b) a : b);
}
value = max (a, b);
或 改 为 如如 下 ⃞
#define MAX (a, b) (((a) > (b)) (a) : (b))
value = MAX (a, b);
仅 供 内 部 使 用 30

软 件 编 程 规 范 总 则
6 函 数 、 过 程
½6-5: 不 要 设 计 多 用 途 面 面 俱 到到 的 函 数 ⃞
说 明 : 多 功 能 集 于 一 身 的 函 数 , 很 可 能 使 函 数 的 理 解 、 测 试 、 维 护 等 变 得 困 难 ⃞
½6-6: 函 数 的 功 能 应 该 是 可 以 预 测 的 , 也 就 是 只 要 输 入 数 据 相 同 就 应 产 生 同 样 的 输 出 ⃞
说 明 : 带 有 内 部 ‚ 存 储 器 ‛ 的 函 数 的 功 能 可 能 是 不 可 预 测 的 , 因 为 它 的 输 出 可 能 取 决 于 内
部 存 储 器 ( 如如 某 标 记 ) 的 状 态 ⃞ 这 样 的 函 数 既 不 易 于 理 解 又 不 利 于 测 试 和和 维 护 ⃞ 在 C/C++
语 言 中 , 函 数 的 static 局 部 变 量 是 函 数 的 内 部 存 储 器 , 有 可 能 使 函 数 的 功 能 不 可 预 测 ,
然 而 , 当 某 函 数 的 返 回 值 为 指 针 类 型 时 , 则 必 须 是 STATIC 的 局 部 变 量 的 地 址 作 为 返 回 值 ,
若 为 AUTO 类 , 则 返 回 为 错 针 ⃞
示 例 : 如如 下 函 数 , 其 返 回 值 ( 即 功 能 ) 是 不 可 预 测 的 ⃞
unsigned int integer_sum( unsigned int base )
{
unsigned int index;
static unsigned int sum = 0; // 注 意 , 是 static 类 型 的 ⃞
// 若 改 为 auto 类 型 , 则 函 数 即 变 为 可 预 测 ⃞
for (index = 1; index

软 件 编 程 规 范 总 则
6 函 数 、 过 程
endp
proc Input_Msg // 过 程 ( 函 数 )Input_Msg
... // 程 序 代 码
LABEL:
... // 程 序 代 码
endp
½6-8: 避 免 设 计 多 参 数 函 数 , 不 使 用 的 参 数 从 接 口 中 去 掉 ⃞
说 明 : 目 的 减 少 函 数 间 接 口 的 复 杂 度 ⃞
½6-9: 非 调 度 函 数 应 减 少 或 防 止 控 制制 参 数 , 尽 量 只 使 用 数 据 参 数 ⃞
说 明 : 本 建 议 目 的 是 防 止 函 数 间 的 控 制制 耦 合 ⃞ 调 度 函 数 是 指 根 据 输 入 的 消 息 类 型 或 控 制制 命命
令 , 来 启启 动 相 应 的 功 能 实 体 ( 即 函 数 或 过 程 ), 而 本 身 并 不 完 成 具 体 功 能 ⃞ 控 制制 参 数 是 指
改 变 函 数 功 能 行 为 的 参 数 , 即 函 数 要 根 据 此 参 数 来 决 定 具 体 怎 样 工 作 ⃞ 非 调 度 函 数 的 控 制制
参 数 增 加 了 函 数 间 的 控 制制 耦 合 , 很 可 能 使 函 数 间 的 耦 合 度 增 大 , 并 使 函 数 的 功 能 不 唯 一 ⃞
示 例 : 如如 下 函 数 构 造 不 太 合 理 ⃞
int add_sub( int a, int b, unsigned char add_sub_flg )
{
if (add_sub_flg == INTEGER_ADD)
{
return (a + b);
}
else
{
return (a b);
}
}
不 如如 分 为 如如 下 两 个 函 数 清 晰 ⃞
int add( int a, int b )
{
return (a + b);
}
仅 供 内 部 使 用 32

软 件 编 程 规 范 总 则
6 函 数 、 过 程
int sub( int a, int b )
{
return (a b);
}
½6-10: 检 查 函 数 所 有 参 数 输 入 的 有 效 性 ⃞
½6-11: 检 查 函 数 所 有 非 参 数 输 入 的 有 效 性 , 如如 数 据 文 件 、 公 共 变 量 等 ⃞
说 明 : 函 数 的 输 入 主 要 有 两 种 : 一 种 是 参 数 输 入 ; 另 一 种 是 全 局 变 量 、 数 据 文 件 的 输 入 ,
即 非 参 数 输 入 ⃞ 函 数 在 使 用 输 入 之 前前 , 应 进 行 必 要 的 检 查 ⃞
½6-12: 函 数 名 应 准 确 描 述 函 数 的 功 能 ⃞
½6-13: 使 用 动 宾 词 组 为 执 行 某 操 作 的 函 数 命命 名 ⃞ 如如 果 是 OOP 方 法 , 可 以 只 有 动 词 ( 名 词 是 对
象 本 身 )⃞
示 例 : 参 照 如如 下 方 式 命命 名 函 数 ⃞
void print_record( unsigned int rec_ind ) ;
int input_record( void ) ;
unsigned char get_current_color( void ) ;
建 议 6-14: 避 免 使 用 无 意 义 或 含 义 不 清 的 动 词 为 函 数 命命 名 ⃞
说 明 : 避 免 用 含 义 不 清 的 动 词 如如 process、handle 等 为 函 数 命命 名 , 因 为 这 些 动 词 并 没 有
说 明 要 具 体 做 什 么 ⃞
建 议 6-15: 函 数 的 返 回 值 要 清 楚 、 明 了 , 让 使 用 者 不 容 易 忽 视 错 误 情 况 ⃞
说 明 : 函 数 的 每 种 出 错 返 回 值 的 意 义 要 清 晰 、 明 了 、 准 确 , 防 止 使 用 者 误 用 、 理 解 错 误 或
忽 视 错 误 返 回 码 ⃞
½6-16: 除 非 必 要 , 最 好好 不 要 把 与 函 数 返 回 值 类 型 不 同 的 变 量 , 以 编 译 系 统 默 认 的 转 换 方 式 或
强 制制 的 转 换 方 式 作 为 返 回 值 返 回 ⃞
½6-17: 让 函 数 在 调 用 点 显 得 易 懂 、 容 易 理 解 ⃞
½6-18: 在 调 用 函 数 填 写 参 数 时 , 应 尽 量 减 少 没 有 必 要 的 默 认 数 据 类 型 转 换 或 强 制制 数 据 类 型 转
换 ⃞
说 明 : 因 为 数 据 类 型 转 换 或 多 或 少 存 在 危 险 ⃞
仅 供 内 部 使 用 33

软 件 编 程 规 范 总 则
6 函 数 、 过 程
½6-19: 避 免 函 数 中 不 必 要 语 句 , 防 止 程 序 中 的 垃 圾 代 码 ⃞
说 明 : 程 序 中 的 垃 圾 代 码 不 仅 占 用 额 外 的 空 间 , 而 且 还 常 常 影 响响 程 序 的 功 能 与 性 能 , 很 可
能 给 程 序 的 测 试 、 维 护 等 造 成 不 必 要 的 麻 烦 ⃞
½6-20: 防 止 把 没 有 关 联 的 语 句 放 到到 一 个 函 数 中 ⃞
说 明 : 防 止 函 数 或 过 程 内 出 现 随 机 内 聚 ⃞ 随 机 内 聚 是 指 将 没 有 关 联 或 关 联 很 弱 的 语 句 放 到到
同 一 个 函 数 或 过 程 中 ⃞ 随 机 内 聚 给 函 数 或 过 程 的 维 护 、 测 试 及 以 后 的 升 级 等 造 成 了 不 便 ,
同 时 也 使 函 数 或 过 程 的 功 能 不 明 确 ⃞ 使 用 随 机 内 聚 函 数 , 常 常 容 易 出 现 在 一 种 应 用 场 合 需
要 改 进 此 函 数 , 而 另 一 种 应 用 场 合 又 不 允 许 这 种 改 进 , 从 而 陷 入 困 境 ⃞
在 编 程 时 , 经 常 遇 到到 在 不 同 函 数 中 使 用 相 同 的 代 码 , 许 多 开 发 人 员员 都 愿 把 这 些 代 码 提 出 来 ,
并 构 成 一 个 新 函 数 ⃞ 若 这 些 代 码 关 联 较 大 并 且 是 完 成 一 个 功 能 的 , 那 么 这 种 构 造 是 合 理 的 ,
否 则 这 种 构 造 将 产 生 随 机 内 聚 的 函 数 ⃞
示 例 : 如如 下 函 数 就 是 一 种 随 机 内 聚 ⃞
void Init_Var( void )
{
Rect.length = 0;
Rect.width = 0; /* 初 始始 化化 矩 形 的 长 与 宽 */
Point.x = 10;
}
Point.y = 10; /* 初 始始 化化 ‚ 点 ‛ 的 坐 标 */
矩 形 的 长 、 宽 与 点 的 坐 标 基 本 没 有 任 何 关 系 , 故 以 上 函 数 是 随 机 内 聚 ⃞
应 如如 下 分 为 两 个 函 数 :
void Init_Rect( void )
{
Rect.length = 0;
Rect.width = 0; /* 初 始始 化化 矩 形 的 长 与 宽 */
}
void Init_Point( void )
{
Point.x = 10;
Point.y = 10; /* 初 始始 化化 ‚ 点 ‛ 的 坐 标 */
仅 供 内 部 使 用 34

软 件 编 程 规 范 总 则
6 函 数 、 过 程
}
½6-21: 如如 果 多 段 代 码 重 复 做 同 一 件 事 情 , 那 么 在 函 数 的 划 分 上 可 能 存 在 问 题 ⃞
说 明 : 若 此 段 代 码 各 语 句 之 间 有 实 质 性 关 联 并 且 是 完 成 同 一 件 功 能 的 , 那 么 可 考 虑 把 此 段
代 码 构 造 成 一 个 新 的 函 数 ⃞
½6-22: 功 能 不 明 确 较 小 的 函 数 , 特 别 是 仅 有 一 个 上 级 函 数 调 用 它 时 , 应 考 虑 把 它 合 并 到到 上 级
函 数 中 , 而 不 必 单 独 存 在 ⃞
说 明 : 模 块 中 函 数 划 分 的 过 多 , 一 般 会 使 函 数 间 的 接 口 变 得 复 杂 ⃞ 所 以 过 小 的 函 数 , 特 别
是 扇 入 很 低 的 或 功 能 不 明 确 的 函 数 , 不 值 得 单 独 存 在 ⃞
½6-23: 设 计 高 扇 入 、 合 理 扇 出 ( 小 于 7) 的 函 数 ⃞
说 明 : 扇 出 是 指 一 个 函 数 直 接 调 用 ( 控 制制 ) 其 它 函 数 的 数 目 , 而 扇 入 是 指 有 多 少 上 级 函 数
调 用 它 ⃞
扇 出 过 大 , 表 明 函 数 过 分 复 杂 , 需 要 控 制制 和和 协 调 过 多 的 下 级 函 数 ; 而 扇 出 过 小 , 如如 总 是 1,
表 明 函 数 的 调 用 层 次 可 能 过 多 , 这 样 不 利 程 序 阅 读 和和 函 数 结 构 的 分 析 , 并 且 程 序 运 行 时 会
对 系 统 资 源 如如 堆 栈 空 间 等 造 成 压 力力 ⃞ 函 数 较 合 理 的 扇 出 ( 调 度 函 数 除 外 ) 通 常 是 3-5⃞ 扇
出 太 大 , 一 般 是 由 于 缺 乏 中 间 层 次 , 可 适 当 增 加 中 间 层 次 的 函 数 ⃞ 扇 出 太 小 , 可 把 下 级 函
数 进 一 步 分 解 多 个 函 数 , 或 合 并 到到 上 级 函 数 中 ⃞ 当 然 分 解 或 合 并 函 数 时 , 不 能 改 变 要 实 现
的 功 能 , 也 不 能 违 背 函 数 间 的 独 立 性 ⃞
扇 入 越 大 , 表 明 使 用 此 函 数 的 上 级 函 数 越 多 , 这 样 的 函 数 使 用 效 率 高 , 但 不 能 违 背 函 数 间
的 独 立 性 而 单 纯 地 追 求 高 扇 入 ⃞ 公 共 模 块 中 的 函 数 及 底 层 函 数 应 该 有 较 高 的 扇 入 ⃞
较 良 好好 的 软 件 结 构 通 常 是 顶 层 函 数 的 扇 出 较 高 , 中 层 函 数 的 扇 出 较 少 , 而 底 层 函 数 则 扇 入
到到 公 共 模 块 中 ⃞
½6-24: 减 少 函 数 本 身 或 函 数 间 的 递 归 调 用 ⃞
说 明 : 递 归 调 用 特 别 是 函 数 间 的 递 归 调 用 ( 如如 A->B->C->A), 影 响响 程 序 的 可 理 解 性 ; 递
归 调 用 一 般 都 占 用 较 多 的 系 统 资 源 ( 如如 栈 空 间 ); 递 归 调 用 对 程 序 的 测 试 有 一 定 影 响响 ⃞ 故
除 非 为 某 些 算 法 或 功 能 的 实 现 方 便 , 应 减 少 没 必 要 的 递 归 调 用 ⃞
½6-25: 仔 细 分 析 模 块 的 功 能 及 性 能 需 求 , 并 进 一 步 细 分 , 同 时 若 有 必 要 画 出 有 关 数 据 流 图 ,
据 此 来 进 行 模 块 的 函 数 划 分 与 组 织 ⃞
说 明 : 函 数 的 划 分 与 组 织 是 模 块 的 实 现 过 程 中 很 关 键 的 步 骤 , 如如 何 划 分 出 合 理 的 函 数 结 构 ,
关 系 到到 模 块 的 最 终 效 率 和和 可 维 护 性 、 可 测 性 等 ⃞ 根 据 模 块 的 功 能 图 或 / 及 数 据 流 图 映 射 出
仅 供 内 部 使 用 35

软 件 编 程 规 范 总 则
6 函 数 、 过 程
函 数 结 构 是 常 用 方 法 之 一 ⃞
½6-26: 改 进 模 块 中 函 数 的 结 构 , 降 低 函 数 间 的 耦 合 度 , 并 提 高 函 数 的 独 立 性 以 及 代 码 可 读 性 、
效 率 和和 可 维 护 性 ⃞ 优 化化 函 数 结 构 时 , 要 遵 守 以 下 原 则 :
(1) 不 能 影 响响 模 块 功 能 的 实 现 ⃞
(2) 仔 细 考 查 模 块 或 函 数 出 错 处 理 及 模 块 的 性 能 要 求 并 进 行 完 善 ⃞
(3) 通 过 分 解 或 合 并 函 数 来 改 进 软 件 结 构 ⃞
(4) 考 查 函 数 的 规 模 , 过 大 的 要 进 行 分 解 ⃞
(5) 降 低 函 数 间 接 口 的 复 杂 度 ⃞
(6) 不 同 层 次 的 函 数 调 用 要 有 较 合 理 的 扇 入 、 扇 出 ⃞
(7) 函 数 功 能 应 可 预 测 ⃞
(8) 提 高 函 数 内 聚 ⃞( 单 一 功 能 的 函 数 内 聚 最 高 )
说 明 : 对 初 步 划 分 后 的 函 数 结 构 应 进 行 改 进 、 优 化化 , 使 之 更 为 合 理 ⃞
½6-27: 在 多 任 务 操 作 系 统 的 环 境 下 编 程 , 要 注 意 函 数 可 重 入 性 的 构 造 ⃞
说 明 : 可 重 入 性 是 指 函 数 可 以 被 多 个 任 务 进 程 调 用 ⃞ 在 多 任 务 操 作 系 统 中 , 函 数 是 否 具 有
可 重 入 性 是 非 常 重 要 的 , 因 为 这 是 多 个 进 程 可 以 共 用 此 函 数 的 必 要 条 件 ⃞ 另 外 , 编 译 器 是
否 提 供 可 重 入 函 数 库 , 与 它 所 服 务 的 操 作 系 统 有 关 , 只 有 操 作 系 统 是 多 任 务 时 , 编 译 器 才
有 可 能 提 供 可 重 入 函 数 库 ⃞ 如如 DOS 下 BC 和和 MSC 等 就 不 具 备 可 重 入 函 数 库 , 因 为 DOS 是
单 用 户 单 任 务 操 作 系 统 ⃞
½6-28: 避 免 使 用 BOOL 参 数 ⃞
说 明 : 原 因 有 二 , 其 一 是 BOOL 参 数 值 无 意 义 ,TURE/FALSE 的 含 义 是 非 常 模 糊 的 , 在 调
用 时 很 难 知 道 该 参 数 到到 底 传 达 的 是 什 么 意 思 ; 其 二 是 BOOL 参 数 值 不 利 于 扩 充 ⃞ 还 有 NULL
也 是 一 个 无 意 义 的 单 词 ⃞
½6-29: 对 于 提 供 了 返 回 值 的 函 数 , 在 引 用 时 最 好好 使 用 其 返 回 值 ⃞
½6-30: 当 一 个 过 程 ( 函 数 ) 中 对 较 长 变 量 ( 一 般 是 结 构 的 成 员员 ) 有 较 多 引 用 时 , 可 以 用 一 个
意 义 相 当 的 宏 代 替 ⃞
说 明 : 这 样 可 以 增 加 编 程 效 率 和和 程 序 的 可 读 性 ⃞
示 例 : 在 某 过 程 中 较 多 引 用 TheReceiveBuffer[FirstSocket].byDataPtr,
则 可 以 通 过 以 下 宏 定 义 来 代 替 :
# define pSOCKDATA TheReceiveBuffer[FirstScoket].byDataPtr
仅 供 内 部 使 用 36

软 件 编 程 规 范 总 则
7 可 测 性
7 可 测 性
¹7-1: 在 同 一 项 目 组 或 产 品品 组 内 , 要 有 一 套套 统 一 的 为 集 成 测 试 与 系 统 联 调 准 备 的 调 测 开 关 及 相
应 打 印 函 数 , 并 且 要 有 详 细 的 说 明 ⃞
说 明 : 本 规 则 是 针 对 项 目 组 或 产 品品 组 的 ⃞
¹7-2: 在 同 一 项 目 组 或 产 品品 组 内 , 调 测 打 印 出 的 信 息 串 的 格 式 要 有 统 一 的 形 式 ⃞ 信 息 串 中 至 少
要 有 所 在 模 块 名 ( 或 源 文 件 名 ) 及 行 号 ⃞
说 明 : 统 一 的 调 测 信 息 格 式 便 于 集 成 测 试 ⃞
¹7-3: 编 程 的 同 时 要 为 单 元 测 试 选 择 恰 当 的 测 试 点 , 并 仔 细 构 造 测 试 代 码 、 测 试 用 例 , 同 时 给
出 明 确 的 注 释 说 明 ⃞ 测 试 代 码 部 分 应 作 为 ( 模 块 中 的 ) 一 个 子 模 块 , 以 方 便 测 试 代 码 在 模 块 中
的 安 装 与 拆 卸 ( 通 过 调 测 开 关 )⃞
说 明 : 为 单 元 测 试 而 准 备 ⃞
¹7-4: 在 进 行 集 成 测 试 / 系 统 联 调 之 前前 , 要 构 造 好好 测 试 环 境 、 测 试 项 目 及 测 试 用 例 , 同 时 仔 细
分 析 并 优 化化 测 试 用 例 , 以 提 高 测 试 效 率 ⃞
说 明 : 好好 的 测 试 用 例 应 尽 可 能 模 拟 出 程 序 所 遇 到到 的 边 界 值 、 各 种 复 杂 环 境 及 一 些 极 端 情 况
等 ⃞
¹7-5: 使 用 断 言 来 发 现 软 件 问 题 , 提 高 代 码 可 测 性 ⃞
说 明 : 断 言 是 对 某 种 假 设 条 件 进 行 检 查 ( 可 理 解 为 若 条 件 成 立 则 无 动 作 , 否 则 应 报 告告 ),
它 可 以 快 速 发 现 并 定 位 软 件 问 题 , 同 时 对 系 统 错 误 进 行 自 动 报 警 ⃞ 断 言 可 以 对 在 系 统 中 隐
藏 很 深 , 用 其 它 手 段 极 难 发 现 的 问 题 进 行 定 位 , 从 而 缩 短 软 件 问 题 定 位 时 间 , 提 高 系 统 的
可 测 性 ⃞ 实 际 应 用 时 , 可 根 据 具 体 情 况 灵 活 地 设 计 断 言 ⃞
示 例 : 下 面 是 C 语 言 中 的 一 个 断 言 , 用 宏 来 设 计 的 ⃞( 其 中 NULL 为 0L)
#ifdef _EXAM_ASSERT_TEST_ // 若 使 用 断 言 测 试
void exam_assert( char * file_name, unsigned int line_no )
{
printf( "\n[EXAM]Assert failed: %s, line %u\n",
file_name, line_no );
abort( );
仅 供 内 部 使 用 37

软 件 编 程 规 范 总 则
7 可 测 性
}
#define EXAM_ASSERT( condition )
if (condition) // 若 条 件 成 立 , 则 无 动 作
NULL;
else // 否 则 报 告告
exam_assert( __FILE__, __LINE__ )
#else // 若 不 使 用 断 言 测 试
#define EXAM_ASSERT(condition) NULL
#endif /* end of ASSERT */
¹7-6: 用 断 言 来 检 查 程 序 正 常 运 行 时 不 应 发 生 但 在 调 测 时 有 可 能 发 生 的 非 法 情 况 ⃞
¹7-7: 不 能 用 断 言 来 检 查 最 终 产 品品 肯 定 会 出 现 且 必 须 处 理 的 错 误 情 况 ⃞
说 明 : 断 言 是 用 来 处 理 不 应 该 发 生 的 错 误 情 况 的 , 对 于 可 能 会 发 生 的 且 必 须 处 理 的 情 况 要
写 防 错 程 序 , 而 不 是 断 言 ⃞ 如如 某 模 块 收 到到 其 它 模 块 或 链 路 上 的 消 息 后 , 要 对 消 息 的 合 理 性
进 行 检 查 , 此 过 程 为 正 常 的 错 误 检 查 , 不 能 用 断 言 来 实 现 ⃞
¹7-8: 对 较 复 杂 的 断 言 加 上 明 确 的 注 释 ⃞
说 明 : 为 复 杂 的 断 言 加 注 释 , 可 澄 清 断 言 含 义 并 减 少 不 必 要 的 误 用 ⃞
¹7-9: 用 断 言 确 认 函 数 的 参 数 ⃞
示 例 : 假 设 某 函 数 参 数 中 有 一 个 指 针 , 那 么 使 用 指 针 前前 可 对 它 检 查 , 如如 下 ⃞
int exam_fun( unsigned char *str )
{
EXAM_ASSERT( str != NULL ); // 用 断 言 检 查 ‚ 假 设 指 针 不 为 空 ‛ 这 个 条 件
}
... //other program code
¹7-10: 用 断 言 保 证 没 有 定 义 的 特 性 或 功 能 不 被 使 用 ⃞
示 例 : 假 设 某 通 信 模 块 在 设 计 时 , 准 备 提 供 ‚ 无 连 接 ‛ 和和 ‚ 连 接 ‛ 这 两 种 业 务 ⃞ 但 当 前前
的 版 本 中 仅 实 现 了 ‚ 无 连 接 ‛ 业 务 , 且 在 此 版 本 的 正 式 发 行 版 中 , 用 户 ( 上 层 模 块 ) 不 应
仅 供 内 部 使 用 38

软 件 编 程 规 范 总 则
7 可 测 性
产 生 ‚ 连 接 ‛ 业 务 的 请 求 , 那 么 在 测 试 时 可 用 断 言 检 查 用 户 是 否 使 用 ‚ 连 接 ‛ 业 务 ⃞ 如如 下 ⃞
#define EXAM_CONNECTIONLESS 0 // 无 连 接 业 务
#define EXAM_CONNECTION
1 // 连 接 业 务
int msg_process( EXAM_MESSAGE *msg )
{
unsigned char service; /* message service class */
EXAM_ASSERT( msg != NULL );
service = get_msg_service_class( msg );
EXAM_ASSERT( service != EXAM_CONNECTION ); // 假 设 不 使 用 连 接 业 务
}
... //other program code
¹7-11: 用 断 言 对 程 序 开 发 环 境 (OS/Compiler/Hardware) 的 假 设 进 行 检 查 ⃞
说 明 : 程 序 运 行 时 所 需 的 软 硬 件 环 境 及 配 置 要 求 , 不 能 用 断 言 来 检 查 , 而 必 须 由 一 段 专 门
代 码 处 理 ⃞ 用 断 言 仅 可 对 程 序 开 发 环 境 中 的 假 设 及 所 配 置 的 某 版 本 软 硬 件 是 否 具 有 某 种 功
能 的 假 设 进 行 检 查 ⃞ 如如 某 网 卡 是 否 在 系 统 运 行 环 境 中 配 置 了 , 应 由 程 序 中 正 式 代 码 来 检 查 ;
而 此 网 卡 是 否 具 有 某 设 想 的 功 能 , 则 可 由 断 言 来 检 查 ⃞
对 编 译 器 提 供 的 功 能 及 特 性 假 设 可 用 断 言 检 查 , 原 因 是 软 件 最 终 产 品品 ( 即 运 行 代 码 或 机 器
码 ) 与 编 译 器 已 没 有 任 何 直 接 关 系 , 即 软 件 运 行 过 程 中 ( 注 意 不 是 编 译 过 程 中 ) 不 会 也 不
应 该 对 编 译 器 的 功 能 提 出 任 何 需 求 ⃞
示 例 : 用 断 言 检 查 编 译 器 的 int 型 数 据 占 用 的 内 存 空 间 是 否 为 2, 如如 下 ⃞
EXAM_ASSERT( sizeof( int ) == 2 );
¹7-12: 正 式 软 件 产 品品 中 应 把 断 言 及 其 它 调 测 代 码 去 掉 ( 即 把 有 关 的 调 测 开 关 关 掉 )⃞
说 明 : 加 快 软 件 运 行 速 度 ⃞
¹7-13: 在 软 件 系 统 中 设 置 与 取 消 有 关 测 试 手 段 , 不 能 对 软 件 实 现 的 功 能 等 产 生 影 响响 ⃞
说 明 : 即 有 测 试 代 码 的 软 件 和和 关 掉 测 试 代 码 的 软 件 , 在 功 能 行 为 上 应 一 致 ⃞
¹7-14: 用 调 测 开 关 来 切 换 软 件 的 DEBUG 版 和和 正 式 版 , 而 不 要 同 时 存 在 正 式 版 本 和和 DEBUG 版 本
仅 供 内 部 使 用 39

软 件 编 程 规 范 总 则
7 可 测 性
的 不 同 源 文 件 , 以 减 少 维 护 的 难 度 ⃞
¹7-15: 软 件 的 DEBUG 版 本 和和 发 行 版 本 应 该 统 一 维 护 , 不 允 许 分 家 , 并 且 要 时 刻刻 注 意 保 证 两 个
版 本 在 实 现 功 能 上 的 一 致 性 ⃞
½7-1: 在 编 写 代 码 之 前前 , 应 预 先 设 计 好好 程 序 调 试 与 测 试 的 方 法 和和 手 段 , 并 设 计 好好 各 种 调 测 开 关
及 相 应 测 试 代 码 如如 打 印 函 数 等 ⃞
说 明 : 程 序 的 调 试 与 测 试 是 软 件 生 存 周周 期 中 很 重 要 的 一 个 阶 段 , 如如 何 对 软 件 进 行 较 全 面 、
高 率 的 测 试 并 尽 可 能 地 找 出 软 件 中 的 错 误 就 成 为 很 关 键 的 问 题 ⃞ 因 此 在 编 写 源 代 码 之 前前 ,
除 了 要 有 一 套套 比 较 完 善 的 测 试 计 划 外 , 还 应 设 计 出 一 系 列 代 码 测 试 手 段 , 为 单 元 测 试 、 集
成 测 试 及 系 统 联 调 提 供 方 便 ⃞
½7-2: 调 测 开 关 应 分 为 不 同 级 别 和和 类 型 ⃞
说 明 : 调 测 开 关 的 设 置 及 分 类 应 从 以 下 几 方 面 考 虑 : 针 对 模 块 或 系 统 某 部 分 代 码 的 调 测 ;
针 对 模 块 或 系 统 某 功 能 的 调 测 ; 出 于 某 种 其 它 目 的 , 如如 对 性 能 、 容 量 等 的 测 试 ⃞ 这 样 做 便
于 软 件 功 能 的 调 测 , 并 且 便 于 模 块 的 单 元 测 试 、 系 统 联 调 等 ⃞
½7-3: 编 写 防 错 程 序 , 然 后 在 处 理 错 误 之 后 可 用 断 言 宣 布 发 生 错 误 ⃞
示 例 : 假 如如 某 模 块 收 到到 通 信 链 路 上 的 消 息 , 则 应 对 消 息 的 合 法 性 进 行 检 查 , 若 消 息 类 别 不
是 通 信 协 议 中 规 定 的 , 则 应 进 行 出 错 处 理 , 之 后 可 用 断 言 报 告告 , 如如 下 例 ⃞
#ifdef _EXAM_ASSERT_TEST_ // 若 使 用 断 言 测 试
/* Notice: this function does not call 'abort' to exit program */
void assert_report( char * file_name, unsigned int line_no )
{
printf( "\n[EXAM]Error Report: %s, line %u\n",
file_name, line_no );
}
#define ASSERT_REPORT( condition )
if ( condition ) // 若 条 件 成 立 , 则 无 动 作
NULL;
else // 否 则 报 告告
assert_report ( __FILE__, __LINE__ )
仅 供 内 部 使 用 40

软 件 编 程 规 范 总 则
7 可 测 性
#else // 若 不 使 用 断 言 测 试
#define ASSERT_REPORT( condition ) NULL
#endif /* end of ASSERT */
int msg_handle( unsigned char msg_name, unsigned char * msg )
{
switch( msg_name )
{
case MSG_ONE:
... // 消 息 MSG_ONE 处 理
return MSG_HANDLE_SUCCESS;
... // 其 它 合 法 消 息 处 理
default:
... // 消 息 出 错 处 理
}
}
ASSERT_REPORT( FALSE ); // ‚ 合 法 ‛ 消 息 不 成 立 , 报 告告
return MSG_HANDLE_ERROR;
仅 供 内 部 使 用 41

软 件 编 程 规 范 总 则
8 程 序 效 率
8 程 序 效 率
¹8-1: 编 程 时 要 经 常 注 意 代 码 的 效 率 ⃞
说 明 : 代 码 效 率 分 为 全 局 效 率 、 局 部 效 率 、 时 间 效 率 及 空 间 效 率 ⃞ 全 局 效 率 是 站 在 整 个 系
统 的 角 度 上 的 系 统 效 率 ; 局 部 效 率 是 站 在 模 块 或 函 数 角 度 上 的 效 率 ; 时 间 效 率 是 程 序 处 理
输 入 任 务 所 需 的 时 间 长 短 ; 空 间 效 率 是 程 序 所 需 内 存 空 间 , 如如 机 器 代 码 空 间 大 小 、 数 据 空
间 大 小 、 栈 空 间 大 小 等 ⃞
¹8-2: 在 保 证 软 件 系 统 的 正 确 性 、 稳 定 性 、 可 读 性 及 可 测 性 的 前前 提 下 , 提 高 代 码 效 率 ⃞
说 明 : 不 能 一 味味 地 追 求 代 码 效 率 , 而 对 软 件 的 正 确 性 、 稳 定 性 、 可 读 性 及 可 测 性 造 成 影 响响 ⃞
¹8-3: 局 部 效 率 应 为 全 局 效 率 服 务 , 不 能 因 为 提 高 局 部 效 率 而 对 全 局 效 率 造 成 影 响响 ⃞
¹8-4: 通 过 对 系 统 数 据 结 构 的 划 分 与 组 织 的 改 进 , 以 及 对 程 序 算 法 的 优 化化 来 提 高 空 间 效 率 ⃞
说 明 : 这 种 方 式 是 解 决 软 件 空 间 效 率 的 根 本 办 法 ⃞
示 例 : 如如 下 记 录 学 生 学 习 成 绩 的 结 构 不 合 理 ⃞
typedef unsigned char BYTE;
typedef unsigned short WORD;
typedef struct STUDENT_SCORE_STRU
BYTE name[8];
BYTE age;
BYTE sex;
BYTE class;
BYTE subject;
float score;
} STUDENT_SCORE;
因 为 每 位 学 生 都 有 多 科 学 习 成 绩 , 故 如如 上 结 构 将 占 用 较 大 空 间 ⃞ 应 如如 下 改 进 ( 分 为 两 个 结
构 ), 总 的 存 贮 空 间 将 变 小 , 操 作 也 变 得 更 方 便 ⃞
typedef struct STUDENT_STRU
{
仅 供 内 部 使 用 42

软 件 编 程 规 范 总 则
8 程 序 效 率
BYTE name[8];
BYTE age;
BYTE sex;
BYTE class;
} STUDENT;
typedef struct STUDENT_SCORE_STRU
{
WORD student_index;
BYTE subject;
float score;
} STUDENT_SCORE;
¹8-5: 循 环 体 内 工 作 量 最 小 化化 ⃞
说 明 : 应 仔 细 考 虑 循 环 体 内 的 语 句 是 否 可 以 放 在 循 环 体 之 外 , 使 循 环 体 内 工 作 量 最 小 , 从
而 提 高 程 序 的 时 间 效 率 ⃞
示 例 : 如如 下 代 码 效 率 不 高 ⃞
for (ind = 0; ind < MAX_ADD_NUMBER; ind++)
{
sum += ind;
back_sum = sum; /* backup sum */
}
语 句 ‚back_sum = sum;‛ 完 全 可 以 放 在 for 语 句 之 后 , 如如 下 ⃞
for (ind = 0; ind < MAX_ADD_NUMBER; ind++)
{
sum += ind;
}
back_sum = sum; /* backup sum */
½8-1: 仔 细 分 析 有 关 算 法 , 并 进 行 优 化化 ⃞
½8-2: 仔 细 考 查 、 分 析 系 统 及 模 块 处 理 输 入 ( 如如 事 务 、 消 息 等 ) 的 方 式 , 并 加 以 改 进 ⃞
½8-3: 对 模 块 中 函 数 的 划 分 及 组 织 方 式 进 行 分 析 、 优 化化 , 改 进 模 块 中 函 数 的 组 织 结 构 , 提 高 程
序 效 率 ⃞
仅 供 内 部 使 用 43

软 件 编 程 规 范 总 则
8 程 序 效 率
说 明 : 软 件 系 统 的 效 率 主 要 与 算 法 、 处 理 任 务 方 式 、 系 统 功 能 及 函 数 结 构 有 很 大 关 系 , 仅
在 代 码 上 下 功 夫 一 般 不 能 解 决 根 本 问 题 ⃞
½8-4: 编 程 时 , 要 随 时 留 心 代 码 效 率 ; 优 化化 代 码 时 , 要 考 虑 周周 全 ⃞
½8-5: 不 应 花 过 多 的 时 间 拼 命命 地 提 高 调 用 不 很 频 繁 的 函 数 代 码 效 率 ⃞
说 明 : 对 代 码 优 化化 可 提 高 效 率 , 但 若 考 虑 不 周周 很 有 可 能 引 起 严 重 后 果 ⃞
½8-6: 要 仔 细 地 构 造 或 直 接 用 汇 编 编 写 调 用 频 繁 或 性 能 要 求 极 高 的 函 数 ⃞
说 明 : 只 有 对 编 译 系 统 产 生 机 器 码 的 方 式 以 及 硬 件 系 统 较 为 熟 悉 时 , 才 可 使 用 汇 编 嵌 入 方
式 ⃞ 嵌 入 汇 编 可 提 高 时 间 及 空 间 效 率 , 但 也 存 在 一 定 风 险 ⃞
½8-7: 在 保 证 程 序 质 量 的 前前 提 下 , 通 过 压 缩 代 码 量 、 去 掉 不 必 要 代 码 以 及 减 少 不 必 要 的 局 部 和和
全 局 变 量 , 来 提 高 空 间 效 率 ⃞
说 明 : 这 种 方 式 对 提 高 空 间 效 率 可 起 到到 一 定 作 用 , 但 往 往 不 能 解 决 根 本 问 题 ⃞
½8-8: 在 多 重 循 环 中 , 应 将 最 忙 的 循 环 放 在 最 内 层 ⃞
说 明 : 减 少 CPU 切 入 循 环 层 的 次 数 ⃞
示 例 : 如如 下 代 码 效 率 不 高 ⃞
for (row = 0; row < 100; row++)
{
for (col = 0; col < 5; col++)
{
sum += a[row][col];
}
}
可 以 改 为 如如 下 方 式 , 以 提 高 效 率 ⃞
for (col = 0; col < 5; col++)
{
for (row = 0; row < 100; row++)
{
sum += a[row][col];
}
}
仅 供 内 部 使 用 44

软 件 编 程 规 范 总 则
8 程 序 效 率
½8-9: 尽 量 减 少 循 环 嵌 套套 层 次 ⃞
½8-10: 避 免 循 环 体 内 含 判 断 语 句 , 应 将 循 环 语 句 置 于 判 断 语 句 的 代 码 块 之 中 ⃞
说 明 : 目 的 是 减 少 判 断 次 数 ⃞ 循 环 体 中 的 判 断 语 句 是 否 可 以 移 到到 循 环 体 外 , 要 视 程 序 的 具
体 情 况 而 言 , 一 般 情 况 , 与 循 环 变 量 无 关 的 判 断 语 句 可 以 移 到到 循 环 体 外 , 而 有 关 的 则 不 可
以 ⃞
示 例 : 如如 下 代 码 效 率 稍 低 ⃞
for (ind = 0; ind < MAX_RECT_NUMBER; ind++)
{
if (data_type == RECT_AREA)
{
area_sum += rect_area[ind];
}
else
{
rect_length_sum += rect[ind].length;
rect_width_sum += rect[ind].width;
}
}
因 为 判 断 语 句 与 循 环 变 量 无 关 , 故 可 如如 下 改 进 , 以 减 少 判 断 次 数 ⃞
if (data_type == RECT_AREA)
{
for (ind = 0; ind < MAX_RECT_NUMBER; ind++)
{
area_sum += rect_area[ind];
}
}
else
{
for (ind = 0; ind < MAX_RECT_NUMBER; ind++)
{
rect_length_sum += rect[ind].length;
rect_width_sum += rect[ind].width;
}
仅 供 内 部 使 用 45

软 件 编 程 规 范 总 则
8 程 序 效 率
}
½8-11: 尽 量 用 乘 法 或 其 它 方 法 代 替 除 法 , 特 别 是 浮 点 运 算 中 的 除 法 ⃞
说 明 : 浮 点 运 算 除 法 要 占 用 较 多 CPU 资 源 ⃞
示 例 : 如如 下 表 达 式 运 算 可 能 要 占 较 多 CPU 资 源 ⃞
#define PAI 3.1416
radius = circle_length / (2 * PAI);
应 如如 下 把 浮 点 除 法 改 为 浮 点 乘 法 ⃞
#define PAI_RECIPROCAL (1 / 3.1416 ) // 编 译 器 编 译 时 , 将 生 成 具 体 浮 点 数
radius = circle_length * PAI_RECIPROCAL / 2;
½8-12: 不 要 一 味味 追 求 紧 凑 的 代 码 ⃞
说 明 : 因 为 紧 凑 的 代 码 并 不 代 表 高 效 的 机 器 码 ⃞
仅 供 内 部 使 用 46

软 件 编 程 规 范 总 则
9 质 量 保 证
9 质 量 保 证
¹9-1: 在 软 件 设 计 过 程 中 构 筑 软 件 质 量 ⃞
¹9-2: 代 码 质 量 保 证 优 先 原 则
(1) 正 确 性 , 指 程 序 要 实 现 设 计 要 求 的 功 能 ⃞
(2) 稳 定 性 、 安 全 性 , 指 程 序 稳 定 、 可 靠 、 安 全 ⃞
(3) 可 测 试 性 , 指 程 序 要 具 有 良 好好 的 可 测 试 性 ⃞
(4) 规 范 / 可 读 性 , 指 程 序 书 写 风 格 、 命命 名 规 则 等 要 符 合 规 范 ⃞
(5) 全 局 效 率 , 指 软 件 系 统 的 整 体 效 率 ⃞
(6) 局 部 效 率 , 指 某 个 模 块 / 子 模 块 / 函 数 的 本 身 效 率 ⃞
(7) 个 人 表 达 方 式 / 个 人 方 便 性 , 指 个 人 编 程 习 惯 ⃞
¹9-3: 只 引 用 属 于 自 己 的 存 贮 空 间 ⃞
说 明 : 若 模 块 封 装 的 较 好好 , 那 么 一 般 不 会 发 生 非 法 引 用 他 人 的 空 间 ⃞
¹9-4: 防 止 引 用 已 经 释 放 的 内 存 空 间 ⃞
说 明 : 在 实 际 编 程 过 程 中 , 稍 不 留 心 就 会 出 现 在 一 个 模 块 中 释 放 了 某 个 内 存 块 ( 如如 C 语 言
指 针 ), 而 另 一 模 块 在 随 后 的 某 个 时 刻刻 又 使 用 了 它 ⃞ 要 防 止 这 种 情 况 发 生 ⃞
¹9-5: 过 程 / 函 数 中 分 配 的 内 存 , 在 过 程 / 函 数 退 出 之 前前 要 释 放 ⃞
¹9-6: 过 程 / 函 数 中 申 请 的 ( 为 打 开 文 件 而 使 用 的 ) 文 件 句 柄 , 在 过 程 / 函 数 退 出 之 前前 要 关 闭 ⃞
说 明 : 分 配 的 内 存 不 释 放 以 及 文 件 句 柄 不 关 闭 , 是 较 常 见 的 错 误 , 而 且 稍 不 注 意 就 有 可 能
发 生 ⃞ 这 类 错 误 往 往 会 引 起 很 严 重 后 果 , 且 难 以 定 位 ⃞
示 例 : 下 函 数 在 退 出 之 前前 , 没 有 把 分 配 的 内 存 释 放 ⃞
typedef unsigned char BYTE;
int example_fun( BYTE gt_len, BYTE *gt_code )
{
BYTE *gt_buf;
gt_buf = (BYTE *) malloc (MAX_GT_LENGTH);
... //program code, include check gt_buf if or not NULL.
仅 供 内 部 使 用 47

软 件 编 程 规 范 总 则
9 质 量 保 证
/* global title length error */
if (gt_len > MAX_GT_LENGTH)
{
return GT_LENGTH_ERROR; // 忘 了 释 放 gt_buf
}
}
... // other program code
应 改 为 如如 下 ⃞
int example_fun( BYTE gt_len, BYTE *gt_code )
{
BYTE *gt_buf;
gt_buf = (BYTE * ) malloc ( MAX_GT_LENGTH );
... // program code, include check gt_buf if or not NULL.
/* global title length error */
if (gt_len > MAX_GT_LENGTH)
{
free( gt_buf ); // 退 出 之 前前 释 放 gt_buf
return GT_LENGTH_ERROR;
}
}
... // other program code
¹9-7: 防 止 内 存 操 作 越 界 ⃞
说 明 : 内 存 操 作 主 要 是 指 对 数 组 、 指 针 、 内 存 地 址 等 的 操 作 ⃞ 内 存 操 作 越 界 是 软 件 系 统 主
要 错 误 之 一 , 后 果 往 往 非 常 严 重 , 所 以 当 我 们 进 行 这 些 操 作 时 一 定 要 仔 细 小 心 ⃞
示 例 : 假 设 某 软 件 系 统 最 多 可 由 10 个 用 户 同 时 使 用 , 用 户 号 为 1-10, 那 么 如如 下 程 序 存 在
问 题 ⃞
#define MAX_USR_NUM 10
unsigned char usr_login_flg[MAX_USR_NUM]= "";
仅 供 内 部 使 用 48

软 件 编 程 规 范 总 则
9 质 量 保 证
void set_usr_login_flg( unsigned char usr_no )
{
if (!usr_login_flg[usr_no])
{
usr_login_flg[usr_no]= TRUE;
}
}
当 usr_no 为 10 时 , 将 使 用 usr_login_flg 越 界 ⃞ 可 采 用 如如 下 方 式 解 决 ⃞
void set_usr_login_flg( unsigned char usr_no )
{
if (!usr_login_flg[usr_no - 1])
{
usr_login_flg[usr_no - 1]= TRUE;
}
}
¹9-8: 认 真 处 理 程 序 所 能 遇 到到 的 各 种 出 错 情 况 ⃞
¹9-9: 系 统 运 行 之 初 , 要 初 始始 化化 有 关 变 量 及 运 行 环 境 , 防 止 未 经 初 始始 化化 的 变 量 被 引 用 ⃞
¹9-10: 系 统 运 行 之 初 , 要 对 加 载 到到 系 统 中 的 数 据 进 行 一 致 性 检 查 ⃞
说 明 : 使 用 不 一 致 的 数 据 , 容 易 使 系 统 进 入 混 乱 状 态 和和 不 可 知 状 态 ⃞
¹9-11: 严 禁 随 意 更 改 其 它 模 块 或 系 统 的 有 关 设 置 和和 配 置 ⃞
说 明 : 编 程 时 , 不 能 随 心 所 欲 地 更 改 不 属 于 自 己 模 块 的 有 关 设 置 如如 常 量 、 数 组 的 大 小 等 ⃞
¹9-12: 不 能 随 意 改 变 与 其 它 模 块 的 接 口 ⃞
¹9-13: 充 分 了 解 系 统 的 接 口 之 后 , 再 使 用 系 统 提 供 的 功 能 ⃞
示 例 : 在 B 型 机 的 各 模 块 与 操 作 系 统 的 接 口 函 数 中 , 有 一 个 要 由 各 模 块 负 责 编 写 的 初 始始 化化
过 程 , 此 过 程 在 软 件 系 统 加 载 完 成 后 , 由 操 作 系 统 发 送 的 初 始始 化化 消 息 来 调 度 ⃞ 因 此 就 涉 及
到到 初 始始 化化 消 息 的 类 型 与 消 息 发 送 的 顺 序 问 题 , 特 别 是 消 息 顺 序 , 若 没 搞 清 楚 就 开 始始 编 程 ,
很 容 易 引 起 严 重 后 果 ⃞ 以 下 示 例 引 自 B 型 曾 出 现 过 的 实 际 代 码 , 其 中 使 用 了
FID_FETCH_DATA 与 FID_INITIAL 初 始始 化化 消 息 类 型 , 注 意 B 型 机 的 系 统 是 在
仅 供 内 部 使 用 49

软 件 编 程 规 范 总 则
9 质 量 保 证
FID_FETCH_DATA 之 前前 发 送 FID_INITIAL 的 ⃞
MID alarm_module_list[MAX_ALARM_MID];
int FAR SYS_ALARM_proc( FID function_id, int handle )
{
_UI i, j;
switch ( function_id )
{
... // program code
case FID_INITAIL:
for (i = 0; i < MAX_ALARM_MID; i++)
{
if (alarm_module_list[i]== BAM_MODULE // **)
|| (alarm_module_list[i]== LOCAL_MODULE)
{
}
}
for (j = 0; j < ALARM_CLASS_SUM; j++)
{
FAR_MALLOC( ... );
}
... // program code
break;
case FID_FETCH_DATA:
... // program code
Get_Alarm_Module( ); // 初 始始 化化 alarm_module_list
仅 供 内 部 使 用 50

软 件 编 程 规 范 总 则
9 质 量 保 证
break;
}
}
... // program code
由 于 FID_INITIAL 是 在 FID_FETCH_DATA 之 前前 执 行 的 , 而 初 始始 化化
alarm_module_list 是 在 FID_FETCH_DATA 中 进 行 的 , 故 在 FID_INITIAL 中 (**)
处 引 用 alarm_module_list 变 量 时 , 它 还 没 有 被 初 始始 化化 ⃞ 这 是 个 严 重 错 误 ⃞
应 如如 下 改 正 : 要 么 把 Get_Alarm_Module 函 数 放 在 FID_INITIAL 中 (**) 之 前前 ; 要
么 就 必 须 考 虑 (**) 处 的 判 断 语 句 是 否 可 以 用 ( 不 使 用 alarm_module_list 变 量 的 )
其 它 方 式 替 代 , 或 者 是 否 可 以 取 消 此 判 断 语 句 ⃞
¹9-14: 编 程 时 , 要 防 止 差 1 错 误 ⃞
说 明 : 此 类 错 误 一 般 是 由 于 把 ‚‛ 等 造 成 的 , 由 此
引 起 的 后 果 , 很 多 情 况 下 是 很 严 重 的 , 所 以 编 程 时 , 一 定 要 在 这 些 地 方 小 心 ⃞ 当 编 完 程 序
后 , 应 对 这 些 操 作 符 进 行 彻 底 检 查 ⃞
¹9-15: 要 时 刻刻 注 意 易 混 淆 的 操 作 符 ⃞ 当 编 完 程 序 后 , 应 从 头头 至 尾 检 查 一 遍 这 些 操 作 符 , 以 防
止 拼 写 错 误 ⃞
说 明 : 形 式 相 近 的 操 作 符 最 容 易 引 起 误 用 , 如如 C/C++ 中 的 ‚=‛ 与 ‚==‛、‚|‛ 与 ‚||‛、
‚&‛ 与 ‚&&‛ 等 , 若 拼 写 错 了 , 编 译 器 不 一 定 能 够 检 查 出 来 ⃞
示 例 : 如如 把 ‚&‛ 写 成 ‚&&‛, 或 反 之 ⃞
ret_flg = (pmsg->ret_flg & RETURN_MASK);
被 写 为 :
ret_flg = (pmsg->ret_flg && RETURN_MASK);
rpt_flg = (VALID_TASK_NO( taskno ) && DATA_NOT_ZERO( stat_data ));
被 写 为 :
rpt_flg = (VALID_TASK_NO( taskno ) & DATA_NOT_ZERO( stat_data ));
¹9-16: 有 可 能 的 话 ,if 语 句 尽 量 加 上 else 分 支 , 对 没 有 else 分 支 的 语 句 要 小 心 对 待 ;switch
语 句 必 须 有 default 分 支 ⃞
仅 供 内 部 使 用 51

软 件 编 程 规 范 总 则
9 质 量 保 证
¹9-17:Unix 下 , 多 线 程 的 中 的 子 线 程 退 出 必 需 采 用 主 动 退 出 方 式 , 即 子 线 程 应 return 出 口 ⃞
¹9-18: 不 要 滥 用 goto 语 句 ⃞
说 明 :goto 语 句 会 破 坏 程 序 的 结 构 性 , 所 以 除 非 确 实 需 要 , 最 好好 不 使 用 goto 语 句 ⃞
½9-1: 不 使 用 与 硬 件 或 操 作 系 统 关 系 很 大 的 语 句 , 而 使 用 建 议 的 标 准 语 句 , 以 提 高 软 件 的 可 移
植 性 和和 可 重 用 性 ⃞
½9-2: 除 非 为 了 满 足 特 殊 需 求 , 避 免 使 用 嵌 入 式 汇 编 ⃞
说 明 : 程 序 中 嵌 入 式 汇 编 , 一 般 都 对 可 移 植 性 有 较 大 的 影 响响 ⃞
½9-3: 精 心 地 构 造 、 划 分 子 模 块 , 并 按 ‚ 接 口 ‛ 部 分 及 ‚ 内 核 ‛ 部 分 合 理 地 组 织 子 模 块 , 以 提
高 ‚ 内 核 ‛ 部 分 的 可 移 植 性 和和 可 重 用 性 ⃞
说 明 : 对 不 同 产 品品 中 的 某 个 功 能 相 同 的 模 块 , 若 能 做 到到 其 内 核 部 分 完 全 或 基 本 一 致 , 那 么
无 论 对 产 品品 的 测 试 、 维 护 , 还 是 对 以 后 产 品品 的 升 级 都 会 有 很 大 帮 助 ⃞
½9-4: 精 心 构 造 算 法 , 并 对 其 性 能 、 效 率 进 行 测 试 ⃞
½9-5: 对 较 关 键 的 算 法 最 好好 使 用 其 它 算 法 来 确 认 ⃞
½9-6: 时 刻刻 注 意 表 达 式 是 否 会 上 溢 、 下 溢 ⃞
示 例 : 如如 下 程 序 将 造 成 变 量 下 溢 ⃞
unsigned char size ;
while (size-- >= 0) // 将 出 现 下 溢
{
... // program code
}
当 size 等 于 0 时 , 再 减 1 不 会 小 于 0, 而 是 0xFF, 故 程 序 是 一 个 死 循 环 ⃞ 应 如如 下 修 改 ⃞
char size; // 从 unsigned char 改 为 char
while (size-- >= 0)
{
... // program code
}
½9-7: 使 用 变 量 时 要 注 意 其 边 界 值 的 情 况 ⃞
仅 供 内 部 使 用 52

软 件 编 程 规 范 总 则
9 质 量 保 证
示 例 : 如如 C 语 言 中 字 符 型 变 量 , 有 效 值 范 围 为 -128 到到 127⃞ 故 以 下 表 达 式 的 计 算 存 在 一
定 风 险 ⃞
char chr = 127;
int sum = 200;
chr += 1; // 127 为 chr 的 边 界 值 , 再 加 1 将 使 chr 上 溢 到到 -128, 而 不 是 128⃞
sum += chr; // 故 sum 的 结 果 不 是 328, 而 是 72⃞
若 chr 与 sum 为 同 一 种 类 型 , 或 表 达 式 按 如如 下 方 式 书 写 , 可 能 会 好好 些 ⃞
sum = sum + chr + 1;
½9-8: 留 心 程 序 机 器 码 大 小 ( 如如 指 令 空 间 大 小 、 数 据 空 间 大 小 、 堆 栈 空 间 大 小 等 ) 是 否 超 出 系
统 有 关 限 制制 ⃞
½9-9: 为 用 户 提 供 良 好好 的 接 口 界 面 , 使 用 户 能 较 充 分 地 了 解 系 统 内 部 运 行 状 态 及 有 关 系 统 出 错
情 况 ⃞
½9-10: 系 统 应 具 有 一 定 的 容 错 能 力力 , 对 一 些 错 误 事 件 ( 如如 用 户 误 操 作 等 ) 能 进 行 自 动 补 救 ⃞
½9-11: 对 一 些 具 有 危 险 性 的 操 作 代 码 ( 如如 写 硬 盘 、 删 数 据 等 ) 要 仔 细 考 虑 , 防 止 对 数 据 、 硬
件 等 的 安 全 构 成 危 害 , 以 提 高 系 统 的 安 全 性 ⃞
½9-12: 使 用 第 三 方 提 供 的 软 件 开 发 工 具 包包 或 控 件 时 , 要 注 意 以 下 几 点 :
(1) 充 分 了 解 应 用 接 口 、 使 用 环 境 及 使 用 时 注 意 事 项 ⃞
(2) 不 能 过 分 相 信 其 正 确 性 ⃞
(3) 除 非 必 要 , 不 要 使 用 不 熟 悉 的 第 三 方 工 具 包包 与 控 件 ⃞
说 明 : 使 用 工 具 包包 与 控 件 , 可 加 快 程 序 开 发 速 度 , 节 省 时 间 , 但 使 用 之 前前 一 定 对 它 有 较 充
分 的 了 解 , 同 时 第 三 方 工 具 包包 与 控 件 也 有 可 能 存 在 问 题 ⃞
½9-13: 资 源 文 件 ( 多 语 言 版 本 支 持 ), 如如 果 资 源 是 对 语 言 敏 感 的 , 应 让 该 资 源 与 源 代 码 文 件
脱 离 , 具 体 方 法 有 下 面 几 种 : 使 用 单 独 的 资 源 文 件 、DLL 文 件 或 其 它 单 独 的 描 述 文 件 ( 如如 数 据
库 格 式 )
仅 供 内 部 使 用 53

软 件 编 程 规 范 总 则
10 代 码 编 辑 、 编 译 、 审 查
10 代 码 编 辑 、 编 译 、 审 查
¹10-1: 打 开 编 译 器 的 所 有 告告 警 开 关 对 程 序 进 行 编 译 ⃞
¹10-2: 在 产 品品 软 件 ( 项 目 组 ) 中 , 要 统 一 编 译 开 关 选 项 ⃞
¹10-3: 通 过 代 码 走 读 及 审 查 方 式 对 代 码 进 行 检 查 ⃞
说 明 : 代 码 走 读 主 要 是 对 程 序 的 编 程 风 格 如如 注 释 、 命命 名 等 以 及 编 程 时 易 出 错 的 内 容 进 行 检
查 , 可 由 开 发 人 员员 自 己 或 开 发 人 员员 交 叉 的 方 式 进 行 ; 代 码 审 查 主 要 是 对 程 序 实 现 的 功 能 及
程 序 的 稳 定 性 、 安 全 性 、 可 靠 性 等 进 行 检 查 及 评 审 , 可 通 过 自 审 、 交 叉 审 核 或 指 定 部 门 抽
查 等 方 式 进 行 ⃞
¹10-4: 测 试 部 测 试 产 品品 之 前前 , 应 对 代 码 进 行 抽 查 及 评 审 ⃞
½10-1: 编 写 代 码 时 要 注 意 随 时 保 存 , 并 定 期 备 份 , 防 止 由 于 断 电 、 硬 盘 损 坏 等 原 因 造 成 代 码
丢 失失 ⃞
½10-2: 同 产 品品 软 件 ( 项 目 组 ) 内 , 最 好好 使 用 相 同 的 编 辑 器 , 并 使 用 相 同 的 设 置 选 项 ⃞
说 明 : 同 一 项 目 组 最 好好 采 用 相 同 的 智 能 语 言 编 辑 器 , 如如 Muiti Editor,Visual Editor
等 , 并 设 计 、 使 用 一 套套 缩 进 宏 及 注 释 宏 等 , 将 缩 进 等 问 题 交 由 编 辑 器 处 理 ⃞
½10-3: 要 小 心 地 使 用 编 辑 器 提 供 的 块 拷 贝 功 能 编 程 ⃞
说 明 : 当 某 段 代 码 与 另 一 段 代 码 的 处 理 功 能 相 似 时 , 许 多 开 发 人 员员 都 用 编 辑 器 提 供 的 块 拷
贝 功 能 来 完 成 这 段 代 码 的 编 写 ⃞ 由 于 程 序 功 能 相 近 , 故 所 使 用 的 变 量 、 采 用 的 表 达 式 等 在
功 能 及 命命 名 上 可 能 都 很 相 近 , 所 以 使 用 块 拷 贝 时 要 注 意 , 除 了 修 改 相 应 的 程 序 外 , 一 定 要
把 使 用 的 每 个 变 量 仔 细 查 看 一 遍 , 以 改 成 正 确 的 ⃞ 不 应 指 望 编 译 器 能 查 出 所 有 这 种 错 误 ,
比 如如 当 使 用 的 是 全 局 变 量 时 , 就 有 可 能 使 某 种 错 误 隐 藏 下 来 ⃞
½10-4: 合 理 地 设 计 软 件 系 统 目 录 , 方 便 开 发 人 员员 使 用 ⃞
说 明 : 方 便 、 合 理 的 软 件 系 统 目 录 , 可 提 高 工 作 效 率 ⃞ 目 录 构 造 的 原 则 是 方 便 有 关 源 程 序
的 存 储 、 查 询 、 编 译 、 链 接 等 工 作 , 同 时 目 录 中 还 应 具 有 工 作 目 录 ---- 所 有 的 编 译 、 链
接 等 工 作 应 在 此 目 录 中 进 行 , 工 具 目 录 ---- 有 关 文 件 编 辑 器 、 文 件 查 找 等 工 具 可 存 放 在
此 目 录 中 ⃞
仅 供 内 部 使 用 54

软 件 编 程 规 范 总 则
10 代 码 编 辑 、 编 译 、 审 查
½10-5: 某 些 语 句 经 编 译 后 产 生 告告 警 , 但 如如 果 你 认 为 它 是 正 确 的 , 那 么 应 通 过 某 种 手 段 去 掉 告告
警 信 息 ⃞
说 明 : 在 Borland C/C++ 中 , 可 用 ‚#pragma warn‛ 来 关 掉 或 打 开 某 些 告告 警 ⃞
示 例 :
#pragma warn -rvl // 关 闭 告告 警
int examples_fun( void )
{
// 程 序 , 但 无 return 语 句 ⃞
}
#pragma warn +rvl // 打 开 告告 警
编 译 函 数 examples_fun 时 本 应 产 生 ‚ 函 数 应 有 返 回 值 ‛ 告告 警 , 但 由 于 关 掉 了 此 告告 警 信
息 显 示 , 所 以 编 译 时 将 不 会 产 生 此 告告 警 提 示 ⃞
½10-6: 使 用 代 码 检 查 工 具 ( 如如 C 语 言 用 PC-Lint) 对 源 程 序 检 查 ⃞
½10-7: 使 用 软 件 工 具 ( 如如 LogiSCOPE) 进 行 代 码 审 查 ⃞
仅 供 内 部 使 用 55

软 件 编 程 规 范 总 则
11 代 码 测 试 、 维 护
11 代 码 测 试 、 维 护
¹11-1: 单 元 测 试 要 求 至 少 达 到到 语 句 覆 盖 ⃞
¹11-2: 单 元 测 试 开 始始 要 跟 踪 每 一 条 语 句 , 并 观 察 数 据 流 及 变 量 的 变 化化 ⃞
¹11-3: 清 理 、 整 理 或 优 化化 后 的 代 码 要 经 过 审 查 及 测 试 ⃞
¹11-4: 代 码 版 本 升 级 要 经 过 严 格 测 试 ⃞
¹11-5: 使 用 工 具 软 件 对 代 码 版 本 进 行 维 护 ⃞
¹11-6: 正 式 版 本 上 软 件 的 任 何 修 改 都 应 有 详 细 的 文 档 记 录 ⃞
½11-1: 发 现 错 误 立 即 修 改 , 并 且 要 记 录 下 来 ⃞
½11-2: 关 键 的 代 码 在 汇 编 级 跟 踪 ⃞
½11-3: 仔 细 设 计 并 分 析 测 试 用 例 , 使 测 试 用 例 覆 盖 尽 可 能 多 的 情 况 , 以 提 高 测 试 用 例 的 效 率 ⃞
½11-4: 尽 可 能 模 拟 出 程 序 的 各 种 出 错 情 况 , 对 出 错 处 理 代 码 进 行 充 分 的 测 试 ⃞
½11-5: 仔 细 测 试 代 码 处 理 数 据 、 变 量 的 边 界 情 况 ⃞
½11-6: 保 留 测 试 信 息 , 以 便 分 析 、 总 结 经 验 及 进 行 更 充 分 的 测 试 ⃞
½11-7: 不 应 通 过 ‚ 试 ‛ 来 解 决 问 题 , 应 寻 找 问 题 的 根 本 原 因 ⃞
½11-8: 对 自 动 消 失失 的 错 误 进 行 分 析 , 搞 清 楚 错 误 是 如如 何 消 失失 的 ⃞
½11-9: 修 改 错 误 不 仅 要 治 表 , 更 要 治 本 ⃞
½11-10: 测 试 时 应 设 法 使 很 少 发 生 的 事 件 经 常 发 生 ⃞
½11-11: 明 确 模 块 或 函 数 处 理 哪哪 些 事 件 , 并 使 它 们 经 常 发 生 ⃞
½11-12: 坚 持 在 编 码 阶 段 就 对 代 码 进 行 彻 底 的 单 元 测 试 , 不 要 等 以 后 的 测 试 工 作 来 发 现 问 题 ⃞
仅 供 内 部 使 用 56

软 件 编 程 规 范 总 则
11 代 码 测 试 、 维 护
½11-13: 去 除 代 码 运 行 的 随 机 性 ( 如如 去 掉 无 用 的 数 据 、 代 码 及 尽 可 能 防 止 并 注 意 函 数 中 的 ‚ 内
部 寄 存 器 ‛ 等 ), 让 函 数 运 行 的 结 果 可 预 测 , 并 使 出 现 的 错 误 可 再 现 ⃞
仅 供 内 部 使 用 57

软 件 编 程 规 范 总 则
11 代 码 测 试 、 维 护
12 宏
¹12-1: 用 宏 定 义 表 达 式 时 , 要 使 用 完 备 的 括 号 ⃞
示 例 : 如如 下 定 义 的 宏 都 存 在 一 定 的 风 险 ⃞
#define RECTANGLE_AREA( a, b ) a * b
#define RECTANGLE_AREA( a, b ) (a * b)
#define RECTANGLE_AREA( a, b ) (a) * (b)
正 确 的 定 义 应 为 :
#define RECTANGLE_AREA( a, b ) ((a) * (b))
¹12-2: 将 宏 所 定 义 的 多 条 表 达 式 放 在 大 括 号 中 ⃞
示 例 : 下 面 的 语 句 只 有 宏 的 第 一 条 表 达 式 被 执 行 ⃞ 为 了 说 明 问 题 ,for 语 句 的 书 写 稍
不 符 规 范 ⃞
#define INTI_RECT_VALUE( a, b )\
a = 0;\
b = 0;
for (index = 0; index < RECT_TOTAL_NUM; index++)
INTI_RECT_VALUE( rect.a, rect.b );
正 确 的 用 法 应 为 :
#define INTI_RECT_VALUE( a, b )\
{\
a = 0;\
b = 0;\
}
for (index = 0; index < RECT_TOTAL_NUM; index++)
{
仅 供 内 部 使 用 58

软 件 编 程 规 范 总 则
11 代 码 测 试 、 维 护
INTI_RECT_VALUE( rect[index].a, rect[index].b );
}
¹12-3: 使 用 宏 时 , 不 允 许 参 数 发 生 变 化化 ⃞
示 例 : 如如 下 用 法 可 能 导 致 错 误 ⃞
#define SQUARE( a ) ((a) * (a))
int a = 5;
int b;
b = SQUARE( a++ ); // 结 果 :a = 7, 即 执 行 了 两 次 增 1⃞
正 确 的 用 法 是 :
b = SQUARE( a );
a++; // 结 果 :a = 6, 即 只 执 行 了 一 次 增 1⃞
_
仅 供 内 部 使 用 59