华为C语言编程规范（下）

目录

六、函数、过程

七、程序效率

八、质量保证

九、代码编辑、编译、审查

十、代码测试、维护

十一、宏

六、函数、过程

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; 
     [申请信号量操作] // 若申请不到“信号量”，说明另外的进程正处于
     Exam = para; // 给 Exam 赋值并计算其平方过程中（即正在使用此
     temp = Square_Exam( ); // 信号），本进程必须等待其释放信号后，才可继
     [释放信号量操作] // 续执行。若申请到信号，则可继续执行，但其
     // 它进程必须等待本进程释放信号量后，才能再使
     // 用本信号。
     return temp; 
} 

6-5：在同一项目组应明确规定对接口函数参数的合法性检查应由函数的调用者负责还是由 接口函数本身负责，缺省是由函数调用者负责。

说明：对于模块间接口函数的参数的合法性检查这一问题，往往有两个极端现象，即：要么 是调用者和被调用者对参数均不作合法性检查，结果就遗漏了合法性检查这一必要的处理过 程，造成问题隐患；要么就是调用者和被调用者均对参数进行合法性检查，这种情况虽不会 造成问题，但产生了冗余代码，降低了效率。

6-6：函数的规模尽量限制在 200 行以内。

说明：不包括注释和空格行。

6-7：一个函数仅完成一件功能，不要设计多用途面面俱到的函数。 说明：多功能集于一身的函数，很可能使函数的理解、测试、维护等变得困难。

6-8：函数的功能应该是可以预测的，也就是只要输入数据相同就应产生同样的输出。

说明：带有内部“存储器”的函数的功能可能是不可预测的，因为它的输出可能取决于内部 存储器（如某标记）的状态。这样的函数既不易于理解又不利于测试和维护。在 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 <= base; index++) 
     { 
         sum += index; 
     }
     return sum; 
}

6-9：尽量不要编写依赖于其他函数内部实现的函数。

说明：此条为函数独立性的基本要求。由于目前大部分高级语言都是结构化的，所以通过具 体语言的语法要求与编译器功能，基本就可以防止这种情况发生。但在汇编语言中，由于其 灵活性，很可能使函数出现这种情况。

示例：如下是在 DOS 下 TASM 的汇编程序例子。过程 Print_Msg 的实现依赖于 Input_Msg 的具体实现，这种程序是非结构化的，难以维护、修改。

... // 程序代码

proc Print_Msg // 过程（函数）

Print_Msg ... // 程序代码

jmp LABEL ... // 程序代码

endp proc Input_Msg // 过程（函数）

Input_Msg ... // 程序代码

LABEL: ... // 程序代码

endp

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：在调用函数填写参数时，应尽量减少没有必要的默认数据类型转换或强制数据类型转换。

说明：因为数据类型转换或多或少存在危险。

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; /* 初始化“点”的坐标 */ 
}

6-21：如果多段代码重复做同一件事情，那么在函数的划分上可能存在问题。

说明：若此段代码各语句之间有实质性关联并且是完成同一件功能的，那么可考虑把此段代 码构造成一个新的函数。

6-22：功能不明确较小的函数，特别是仅有一个上级函数调用它时，应考虑把它合并到上级 函数中，而不必单独存在。

说明：模块中函数划分的过多，一般会使函数间的接口变得复杂。所以过小的函数，特别是 扇入很低的或功能不明确的函数，不值得单独存在。

6-23：设计高扇入、合理扇出（小于 7）的函数。

说明：扇出是指一个函数直接调用（控制）其它函数的数目，而扇入是指有多少上级函数调 用它。 扇出过大，表明函数过分复杂，需要控制和协调过多的下级函数；而扇出过小，如总是 1， 表明函数的调用层次可能过多，这样不利程序阅读和函数结构的分析，并且程序运行时会对 系统资源如堆栈空间等造成压力。函数较合理的扇出（调度函数除外）通常是 3-5。扇出太 大，一般是由于缺乏中间层次，可适当增加中间层次的函数。扇出太小，可把下级函数进一 步分解多个函数，或合并到上级函数中。当然分解或合并函数时，不能改变要实现的功能， 也不能违背函数间的独立性。 扇入越大，表明使用此函数的上级函数越多，这样的函数使用效率高，但不能违背函数间的 独立性而单纯地追求高扇入。公共模块中的函数及底层函数应该有较高的扇入。 较良好的软件结构通常是顶层函数的扇出较高，中层函数的扇出较少，而底层函数则扇入到 公共模块中。

6-24：减少函数本身或函数间的递归调用。

说明：递归调用特别是函数间的递归调用（如 A->B->C->A），影响程序的可理解性；递归 调用一般都占用较多的系统资源（如栈空间）；递归调用对程序的测试有一定影响。故除非 为某些算法或功能的实现方便，应减少没必要的递归调用。

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

七、程序效率

7-1：编程时要经常注意代码的效率。

说明：代码效率分为全局效率、局部效率、时间效率及空间效率。全局效率是站在整个系统 的角度上的系统效率；局部效率是站在模块或函数角度上的效率；时间效率是程序处理输入 任务所需的时间长短；空间效率是程序所需内存空间，如机器代码空间大小、数据空间大小、 栈空间大小等。

7-2：在保证软件系统的正确性、稳定性、可读性及可测性的前提下，提高代码效率。

说明：不能一味地追求代码效率，而对软件的正确性、稳定性、可读性及可测性造成影响。

7-3：局部效率应为全局效率服务，不能因为提高局部效率而对全局效率造成影响。

7-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 
{ 
     BYTE name[8]; 
     BYTE age; 
     BYTE sex; 
     BYTE class; 
} STUDENT; 
typedef struct STUDENT_SCORE_STRU 
{ 
     WORD student_index; 
     BYTE subject; 
     float score; 
} STUDENT_SCORE;

7-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 */

7-6：仔细分析有关算法，并进行优化。仔细考查、分析系统及模块处理输入（如事务、消 息等）的方式，并加以改进。

7-7：对模块中函数的划分及组织方式进行分析、优化，改进模块中函数的组织结构，提高 程序效率。

说明：软件系统的效率主要与算法、处理任务方式、系统功能及函数结构有很大关系，仅在 代码上下功夫一般不能解决根本问题。

7-8：编程时，要随时留心代码效率；优化代码时，要考虑周全。

7-9：不应花过多的时间拼命地提高调用不很频繁的函数代码效率。

说明：对代码优化可提高效率，但若考虑不周很有可能引起严重后果。

7-10：要仔细地构造或直接用汇编编写调用频繁或性能要求极高的函数。

说明：只有对编译系统产生机器码的方式以及硬件系统较为熟悉时，才可使用汇编嵌入方式。 嵌入汇编可提高时间及空间效率，但也存在一定风险。

7-11：在保证程序质量的前提下，通过压缩代码量、去掉不必要代码以及减少不必要的局部 和全局变量，来提高空间效率。

说明：这种方式对提高空间效率可起到一定作用，但往往不能解决根本问题。

7-12：在多重循环中，应将最忙的循环放在最内层。

说明：减少 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]; 
     } 
} 

7-13：尽量减少循环嵌套层次。

7-14：避免循环体内含判断语句，应将循环语句置于判断语句的代码块之中。

说明：目的是减少判断次数。循环体中的判断语句是否可以移到循环体外，要视程序的具体 情况而言，一般情况，与循环变量无关的判断语句可以移到循环体外，而有关的则不可以。

示例：如下代码效率稍低。

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; 
     } 
}

7-15：尽量用乘法或其它方法代替除法，特别是浮点运算中的除法。

说明：浮点运算除法要占用较多 CPU 资源。

示例：如下表达式运算可能要占较多 CPU 资源。

#define PAI 3.1416

radius = circle_length / (2 * PAI);

应如下把浮点除法改为浮点乘法。

#define PAI_RECIPROCAL (1 / 3.1416 ) // 编译器编译时，将生成具体浮点数

radius = circle_length * PAI_RECIPROCAL / 2;

7-16：不要一味追求紧凑的代码。

说明：因为紧凑的代码并不代表高效的机器码。

八、质量保证

8-1：在软件设计过程中构筑软件质量。

8-2：代码质量保证优先原则

（1）正确性，指程序要实现设计要求的功能。

（2）稳定性、安全性，指程序稳定、可靠、安全。

（3）可测试性，指程序要具有良好的可测试性。

（4）规范/可读性，指程序书写风格、命名规则等要符合规范。

（5）全局效率，指软件系统的整体效率。

（6）局部效率，指某个模块/子模块/函数的本身效率。

（7）个人表达方式/个人方便性，指个人编程习惯。

8-3：只引用属于自己的存贮空间。

说明：若模块封装的较好，那么一般不会发生非法引用他人的空间。

8-4：防止引用已经释放的内存空间。

说明：在实际编程过程中，稍不留心就会出现在一个模块中释放了某个内存块（如 C 语言 指针），而另一模块在随后的某个时刻又使用了它。要防止这种情况发生。

8-5：过程/函数中分配的内存，在过程/函数退出之前要释放。

8-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. 
 
     /* 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 
}    

8-7：防止内存操作越界。

说明：内存操作主要是指对数组、指针、内存地址等的操作。内存操作越界是软件系统主要 错误之一，后果往往非常严重，所以当我们进行这些操作时一定要仔细小心。

示例：假设某软件系统最多可由 10 个用户同时使用，用户号为 1-10，那么如下程序存在问题。

#define MAX_USR_NUM 10 
unsigned char usr_login_flg[MAX_USR_NUM]= ""; 
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; 
     } 
} 

8-8：认真处理程序所能遇到的各种出错情况。

8-9：系统运行之初，要初始化有关变量及运行环境，防止未经初始化的变量被引用。

8-10：系统运行之初，要对加载到系统中的数据进行一致性检查。

说明：使用不一致的数据，容易使系统进入混乱状态和不可知状态。

8-11：严禁随意更改其它模块或系统的有关设置和配置。

说明：编程时，不能随心所欲地更改不属于自己模块的有关设置如常量、数组的大小等。

8-12：不能随意改变与其它模块的接口。

8-13：充分了解系统的接口之后，再使用系统提供的功能。

示例：在 B 型机的各模块与操作系统的接口函数中，有一个要由各模块负责编写的初始化 过程，此过程在软件系统加载完成后，由操作系统发送的初始化消息来调度。因此就涉及到 初始化消息的类型与消息发送的顺序问题，特别是消息顺序，若没搞清楚就开始编程，很容 易引起严重后果。以下示例引自 B 型曾出现过的实际代码，其中使用了 FID_FETCH_DATA 与 FID_INITIAL 初始化消息类型，注意 B 型机的系统是在 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 
        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 变量的）其它方式替代，或 者是否可以取消此判断语句。

8-14：编程时，要防止差 1 错误。

说明：此类错误一般是由于把“=”误写成“>”等造成的，由此引 起的后果，很多情况下是很严重的，所以编程时，一定要在这些地方小心。当编完程序后， 应对这些操作符进行彻底检查。

8-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 ));

8-16：有可能的话，if 语句尽量加上 else 分支，对没有 else 分支的语句要小心对待；switch 语句必须有 default 分支。

8-17：Unix 下，多线程的中的子线程退出必需采用主动退出方式，即子线程应 return 出口。

8-18：不要滥用 goto 语句。

说明：goto 语句会破坏程序的结构性，所以除非确实需要，最好不使用 goto 语句。

8-19：精心地构造、划分子模块，并按“接口”部分及“内核”部分合理地组织子模块，以 提高“内核”部分的可移植性和可重用性。

说明：对不同产品中的某个功能相同的模块，若能做到其内核部分完全或基本一致，那么无 论对产品的测试、维护，还是对以后产品的升级都会有很大帮助。

8-20：精心构造算法，并对其性能、效率进行测试。

8-21：对较关键的算法最好使用其它算法来确认。

8-22：时刻注意表达式是否会上溢、下溢。

示例：如下程序将造成变量下溢。

unsigned char size ; 
while (size-- >= 0) // 将出现下溢
{ 
     ... // program code 
}

当 size 等于 0 时，再减 1 不会小于 0，而是 0xFF，故程序是一个死循环。应如下修改。

char size; // 从 unsigned char 改为 char 
while (size-- >= 0) 
{ 
     ... // program code 
}

8-23：使用变量时要注意其边界值的情况。

示例：如 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;

8-24：留心程序机器码大小（如指令空间大小、数据空间大小、堆栈空间大小等）是否超出 系统有关限制。

8-25：为用户提供良好的接口界面，使用户能较充分地了解系统内部运行状态及有关系统出 错情况。

8-26：系统应具有一定的容错能力，对一些错误事件（如用户误操作等）能进行自动补救。

8-27：对一些具有危险性的操作代码（如写硬盘、删数据等）要仔细考虑，防止对数据、硬 件等的安全构成危害，以提高系统的安全性。

8-28：使用第三方提供的软件开发工具包或控件时，要注意以下几点：

（1）充分了解应用接口、使用环境及使用时注意事项。

（2）不能过分相信其正确性。

（3）除非必要，不要使用不熟悉的第三方工具包与控件。

说明：使用工具包与控件，可加快程序开发速度，节省时间，但使用之前一定对它有较充分 的了解，同时第三方工具包与控件也有可能存在问题。

8-29：资源文件（多语言版本支持），如果资源是对语言敏感的，应让该资源与源代码文件 脱离，具体方法有下面几种：使用单独的资源文件、DLL 文件或其它单独的描述文件（如 数据库格式）

九、代码编辑、编译、审查

9-1：打开编译器的所有告警开关对程序进行编译。

9-2：在产品软件（项目组）中，要统一编译开关选项。

9-3：通过代码走读及审查方式对代码进行检查。

说明：代码走读主要是对程序的编程风格如注释、命名等以及编程时易出错的内容进行检查， 可由开发人员自己或开发人员交叉的方式进行；代码审查主要是对程序实现的功能及程序的 稳定性、安全性、可靠性等进行检查及评审，可通过自审、交叉审核或指定部门抽查等方式 进行。

9-4：测试部测试产品之前，应对代码进行抽查及评审。

9-5：编写代码时要注意随时保存，并定期备份，防止由于断电、硬盘损坏等原因造成代码 丢失。

9-6：同产品软件（项目组）内，最好使用相同的编辑器，并使用相同的设置选项。

说明：同一项目组最好采用相同的智能语言编辑器，如 Muiti Editor，Visual Editor 等，并设 计、使用一套缩进宏及注释宏等，将缩进等问题交由编辑器处理。

9-7：合理地设计软件系统目录，方便开发人员使用。

说明：方便、合理的软件系统目录，可提高工作效率。目录构造的原则是方便有关源程序的 存储、查询、编译、链接等工作，同时目录中还应具有工作目录----所有的编译、链接等工 作应在此目录中进行，工具目录----有关文件编辑器、文件查找等工具可存放在此目录中。

9-8：某些语句经编译后产生告警，但如果你认为它是正确的，那么应通过某种手段去掉告 警信息。

说明：在 Borland C/C++中，可用“#pragma warn”来关掉或打开某些告警。

示例：

#pragma warn -rvl // 关闭告警
int examples_fun( void ) 
{ 
     // 程序，但无 return 语句。
} 
#pragma warn +rvl // 打开告警

编译函数 examples_fun 时本应产生“函数应有返回值”告警，但由于关掉了此告警信息显示，所以编译时将不会产生此告警提示。

9-9：使用代码检查工具（如 C 语言用 PC-Lint）对源程序检查。

9-10:  使用软件工具（如 LogiSCOPE）进行代码审查。

十、代码测试、维护

10-1：单元测试要求至少达到语句覆盖。

10-2：单元测试开始要跟踪每一条语句，并观察数据流及变量的变化。

10-3：清理、整理或优化后的代码要经过审查及测试。

10-4：代码版本升级要经过严格测试。

10-5：使用工具软件对代码版本进行维护。

10-6：正式版本上软件的任何修改都应有详细的文档记录。

10-7：发现错误立即修改，并且要记录下来。

10-8：关键的代码在汇编级跟踪。

10-9：仔细设计并分析测试用例，使测试用例覆盖尽可能多的情况，以提高测试用例的效率。

10-11：尽可能模拟出程序的各种出错情况，对出错处理代码进行充分的测试。

10-12：仔细测试代码处理数据、变量的边界情况。

10-13：保留测试信息，以便分析、总结经验及进行更充分的测试。

10-14：不应通过“试”来解决问题，应寻找问题的根本原因。

10-15：对自动消失的错误进行分析，搞清楚错误是如何消失的。

10-16：修改错误不仅要治表，更要治本。

10-17：测试时应设法使很少发生的事件经常发生。

10-18：明确模块或函数处理哪些事件，并使它们经常发生。

10-19：坚持在编码阶段就对代码进行彻底的单元测试，不要等以后的测试工作来发现问题。

10-20：去除代码运行的随机性（如去掉无用的数据、代码及尽可能防止并注意函数中的“内 部寄存器”等），让函数运行的结果可预测，并使出现的错误可再现。

十一、宏

11-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))

11-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++) 
{ 
     INTI_RECT_VALUE( rect[index].a, rect[index].b ); 
}

11-3:使用宏时，不允许参数发生变化。

示例：如下用法可能导致错误。

#define SQUARE( a ) ((a) * (a)) 

int a = 5; 
int b; 
b = SQUARE( a++ ); // 结果：a = 7，即执行了两次增 1。

正确的用法是：

b = SQUARE( a ); 
a++; // 结果：a = 6，即只执行了一次增 1。

华为C语言编程规范总则（上）-CSDN博客