C语言开发规范.docx

C语言开发规范.docx

《C语言开发规范.docx》由会员分享，可在线阅读，更多相关《C语言开发规范.docx（17页珍藏版）》请在冰点文库上搜索。

C语言开发规范

软件开发规范

在研究项目团队协作开发的情况下（这里的团队协作也适合于应用项目的开发），编程时应该强调的一个重要方面是程序的易读性，在保证软件速度等性能指标能满足用户需求的情况下，能让其他程序员容易读懂你所编写的程序。

若研究项目小组的所有开发人员都遵循统一的、鲜明的一套编程风格，可以让协作者、后继者和自己一目了然，在很短的时间内看清楚程序结构，理解设计的思路，大大提高代码的可读性、可重用性、程序健壮性、可移植性、可维护性。

制定本编程规范的目的是为了提高软件开发效率及所开发软件的可维护性，提高软件的质量。

本规范由程序风格、命名规范、注释规范、程序健壮性、可移植性、错误处理以及软件的模块化规范等部分组成。

本软件开发规范适合讨论C/C++程序设计。

1文件结构

每个C++/C程序通常分为两个文件。

一个文件用于保存程序的声明（declaration），称为头文件。

另一个文件用于保存程序的实现（implementation），称为定义（definition）文件。

C++/C程序的头文件以“.h”为后缀，C程序的定义文件以“.c”为后缀，C++程序的定义文件通常以“.cpp”为后缀（也有一些系统以“.cc”或“.cxx”为后缀）。

文件信息声明

文件信息声明位于头文件和定义文件的开头（参见示例1-1），主要内容有：

（1）      版权信息；

（2）      文件名称，项目代码，摘要，参考文献；

？

（3）      当前版本号，作者/修改者，完成日期；

（4）      版本历史信息；

（5）      主要函数描述。

....

.

|

....

例如一个short*型的变量应该表示为pnStart；

☆    【规则】全局变量用g_开头；例如一个全局的长型变量定义为g_lFileNum，

即：

变量名＝g_＋变量类型＋变量的英文意思（或缩写）；

☆    【规则】静态变量采用s_开头；例如一个静态的指针变量定义为s_plPrevInst，

即：

变量名＝s_＋变量类型＋变量的英文意思（或缩写）；

☆    【规则】类成员变量采用m_开头；例如一个长型成员变量定义为m_lCount，

即：

变量名＝m_＋变量类型＋变量的英文意思（或缩写）；

☆      【规则】对const的变量要求在变量的命名规则前加入c_（若作为函数的输入参数，可以不加），

即：

变量名＝c_＋变量命名规则，例如：

*

constchar*c_szFileName；

☆      【规则】对枚举类型（enum）中的变量，要求用枚举变量或其缩写做前缀，且用下划线隔离变量名，所有枚举类型都要用大写，例如：

enumEMDAYS

{

EMDAYS_MONDAY;

EMDAYS_TUESDAY;

......

}；

☆      【规则】对常量（包括错误的编码）命名，要求常量名用大写，常量名用英文意思表示其意思，用下划线分割单词，例如：

#defineCM_7816_OK0x9000；

☆      【规则】为了防止某一软件库中的一些标识符和其它软件库中的冲突，可以为各种标识符加上能反映软件性质的前缀。

例如三维图形标准OpenGL的所有库函数均以gl开头，所有常量（或宏定义）均以GL开头。

·

3程序风格

程序风格虽然不会影响程序的功能，但会影响程序的可读性，追求清晰、美观，是程序风格的重要构成因素。

空行

空行起着分隔程序段落的作用。

空行得体（不过多也不过少）将使程序的布局更加清晰。

空行不会浪费内存，虽然打印含有空行的程序是会多消耗一些纸张，但是值得。

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

参见示例（a）；

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

参见示例（b）；

<

、“->”这类操作符前后不加空格；

☆      【建议】对于表达式比较长的for语句和if语句，为了紧凑起见可以适当地去掉一些空格，如for（i=0;i<10;i++）和if（（a<=b）&&（c<=d））

.

voidFunc1（intx,inty,intz）;

Function（）;

b->Function（）;

]

~

.*/”，而采用多行“.*/”。

....

//Returnvalue：

Describethepossiblereturnvalue

//Designedidea：

Describedesignedideaaboutthefunction

//Author：

//Creationdate：

Creationdate（YY-MM-DD）

、

//Transferredfunction：

Listthesub-functioninthefunction

//Modificationrecord：

//

（一）Mender1：

Modifieddate：

modifiedcontent

//////////////////////////////////////////////////////////////////////////////////////////////

4函数设计

函数是C++/C程序的基本功能单元，其重要性不言而喻。

函数设计的细微缺点很容易导致该函数被错用，所以光使函数的功能正确是不够的。

本章重点论述函数的接口设计和内部实现的一些规则。

函数接口的两个要素是参数和返回值。

C语言中，函数的参数和返回值的传递方式有两种：

值传递（passbyvalue）和指针传递（passbypointer）。

C++语言中多了引用传递（passbyreference）。

由于引用传递的性质象指针传递，而使用方式却象值传递，初学者常常迷惑不解，容易引起混乱，请先阅读节“引用与指针的比较”。

参数的规则

☆      【规则】参数的书写要完整，不要贪图省事只写参数的类型而省略参数名字，如果函数没有参数，则用void填充；例如：

voidSetValue（intnWidth,intnHeight）;//良好的风格

voidSetValue（int,int）;//不良的风格

】

floatGetValue（void）;//良好的风格

floatGetValue（）;//不良的风格

☆      【规则】参数命名要恰当，顺序要合理；

例如编写字符串拷贝函数StringCopy，它有两个参数，如果把参数名字起为str1和str2，例如：

voidStringCopy（char*str1,char*str2）;

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

这样从名字上就可以看出应该把strSource拷贝到strDestination。

还有一个问题，这两个参数那一个该在前那一个该在后参数的顺序要遵循程序员的习惯。

一般地，应将目的参数放在前面，源参数放在后面。

如果将函数声明为：

voidStringCopy（char*strSource,char*strDestination）;

别人在使用时可能会不假思索地写成如下形式：

charstr[20];

StringCopy（str,“HelloWorld”）;//参数顺序颠倒 

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

例如：

#

voidStringCopy（char*strDestination，constchar*strSource）;

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

☆      【建议】避免函数有太多的参数，参数个数尽量控制在5个以内。

如果参数太多，在使用时容易将参数类型或顺序搞错；

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

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

intprintf（constchat*format[,argument]…）;

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

返回值的规则

☆      【规则】不要省略返回值的类型；

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

C++语言有很严格的类型安全检查，不允许上述情况发生。

由于C++程序可以调用C函数，为了避免混乱，规定任何C++/C函数都必须有类型。

如果函数没有返回值，那么应声明为void类型

~

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

违反这条规则的典型代表是C标准库函数getchar。

例如：

charc;

c=getchar（）;

if（c==EOF）

…

按照getchar名字的意思，将变量c声明为char类型是很自然的事情。

但不幸的是getchar的确不是char类型，而是int类型，其原型如下：

intgetchar（void）;

由于c是char类型，取值范围是[-128，127]，如果宏EOF的值在char的取值范围之外，那么if语句将总是失败，这种“危险”人们一般哪里料得到！

导致本例错误的责任并不在用户，是函数getchar误导了使用者

☆      【规则】不要将正常值和错误标志混在一起返回。

正常值用输出参数获得，而错误标志用return语句返回；

}

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

例如字符串拷贝函数strcpy的原型：

char*strcpy（char*strDest，constchar*strSrc）;

strcpy函数将strSrc拷贝至输出参数strDest中，同时函数的返回值又是strDest。

这样做并非多此一举，可以获得如下灵活性：

charstr[20];

intnLength=strlen（strcpy（str,“HelloWorld”））;

☆      【建议】如果函数的返回值是一个对象，有些场合用“引用传递”替换“值传递”可以提高效率。

而有些场合只能用“值传递”而不能用“引用传递”，否则会出错；

对于建议，如果函数的返回值是一个对象，有些场合用“引用传递”替换“值传递”可以提高效率，而有些场合只能用“值传递”而不能用“引用传递”，否则会出错，例如：

classString

{…

^

//赋值函数

String&operate=（constString&other）;

//相加函数，如果没有friend修饰则只许有一个右侧参数

friendStringoperate+（constString&s1,constString&s2）;

private:

char*m_data;

};

String的赋值函数operate=的实现如下：

String&String:

:

operate=（constString&other）

{

.

if（this==&other）

return*this;

deletem_data;

m_data=newchar[strlen+1];

strcpy（m_data,;

return*this;//返回的是*this的引用，无需拷贝过程

}

对于赋值函数，应当用“引用传递”的方式返回String对象。

如果用“值传递”的方式，虽然功能仍然正确，但由于return语句要把*this拷贝到保存返回值的外部存储单元之中，增加了不必要的开销，降低了赋值函数的效率。

例如：

Stringa,b,c;

…

…

a=b;//如果用“值传递”，将产生一次*this拷贝

a=b=c;//如果用“值传递”，将产生两次*this拷贝

String的相加函数operate+的实现如下：

Stringoperate+（constString&s1,constString&s2）

{

Stringtemp;

delete;//是仅含‘\0’的字符串

=newchar[strlen+strlen+1];

strcpy,;

strcat,;

？

returntemp;

}

对于相加函数，应当用“值传递”的方式返回String对象。

如果改用“引用传递”，那么函数返回值是一个指向局部对象temp的“引用”。

由于temp在函数结束时被自动销毁，将导致返回的“引用”无效。

例如：

c=a+b;

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

函数内部实现的规则

不同功能的函数其内部实现各不相同，看起来似乎无法就“内部实现”达成一致的观点。

但根据经验，我们可以在函数体的“入口处”和“出口处”从严把关，从而提高函数的质量。

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

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

详见节“使用断言”

（

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

注意事项如下：

（1）     return语句不可返回指向“栈内存”的“指针”或者“引用”，因为该内存在函数体结束时被自动销毁，例如：

char*Func（void）

{

charstr[]=“helloworld”;//str的内存位于栈上

…

returnstr;//将导致错误

}

（2）     要搞清楚返回的究竟是“值”、“指针”还是“引用”；

》

（3）     如果函数返回值是一个对象，要考虑return语句的效率，例如：

returnString（s1+s2）;

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

Stringtemp（s1+s2）;

returntemp;

实质不然，上述代码将发生三件事。

首先，temp对象被创建，同时完成初始化；

然后拷贝构造函数把temp拷贝到保存返回值的外部存储单元中；

最后，temp在函数结束时被销毁（调用析构函数）。

然而“创建一个临时对象并返回它”的过程是不同的，编译器直接把临时对象创建并初始化在外部存储单元中，省去了拷贝和析构的化费，提高了效率。

类似地，我们不要将

【

returnint（x+y）;//创建一个临时变量并返回它

写成

inttemp=x+y;

returntemp;

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

其它建议

☆      【建议】函数的功能要单一，不要设计多用途的函数；

☆      【建议】函数体的规模要小，尽量控制在150行代码之内；

☆      【建议】尽量避免函数带有“记忆”功能。

相同的输入应当产生相同的输出带有“记忆”功能的函数，其行为可能是不可预测的，因为它的行为可能取决于某种“记忆状态”。

这样的函数既不易理解又不利于测试和维护。

在C/C++语言中，函数的static局部变量是函数的“记忆”存储器。

建议尽量少用static局部变量，除非必需。

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

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

>

使用断言

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

断言assert是仅在Debug版本起作用的宏，它用于检查“不应该”发生的情况。

示例是一个内存复制函数。

在运行过程中，如果assert的参数为假，那么程序就会中止（一般地还会出现提示对话，说明在什么地方引发了assert）。

void*memcpy（void*pvTo,constvoid*pvFrom,size_tsize）

{

assert（（pvTo!

=NULL）&&（pvFrom!

=NULL））;//使用断言

byte*pbTo=（byte*）pvTo;//防止改变pvTo的地址

byte*pbFrom=（byte*）pvFrom;//防止改变pvFrom的地址

while（size-->0）

*pbTo++=*pbFrom++;

returnpvTo;

}

示例复制不重叠的内存块

assert不是一个仓促拼凑起来的宏。

为了不在程序的Debug版本和Release版本引起差别，assert不应该产生任何副作用。

所以assert不是函数，而是宏。

程序员可以把assert看成一个在任何系统状态下都可以安全使用的无害测试手段。

如果程序在assert处终止了，并不是说含有该assert的函数有错误，而是调用者出了差错，assert可以帮助我们找到发生错误的原因。

☆      【规则】使用断言捕捉不应该发生的非法情况，不要混淆非法情况与错误情况之间的区别，后者是必然存在的并且是一定要作出处理的；

☆      【规则】在函数的入口处，使用断言检查参数的有效性（合法性）；

☆      【建议】在编写函数时，要进行反复的考查，并且自问：

“我打算做哪些假定”一旦确定了的假定，就要使用断言对假定进行检查；

☆      【建议】一般教科书都鼓励程序员们进行防错设计，但要记住这种编程风格可能会隐瞒错误。

当进行防错设计时，如果“不可能发生”的事情的确发生了，则要使用断言进行报警。

引用与指针的比较

&

引用是C++中的概念，初学者容易把引用和指针混淆一起。

一下程序中，n是m的一个引用（reference），m是被引用物（referent）。

intm;

int&n=m;

n相当于m的别名（绰号），对n的任何操作就是对m的操作。

所以n既不是m的拷贝，也不是指向m的指针，其实n就是m它自己。

引用的一些规则如下：

（1）      引用被创建的同时必须被初始化（指针则可以在任何时候被初始化）；

（2）      不能有NULL引用，引用必须与合法的存储单元关联（指针则可以是NULL）；

（3）      一旦引用被初始化，就不能改变引用的关系（指针则可以随时改变所指的对象）。

以下示例程序中，k被初始化为i的引用。

语句k=j并不能将k修改成为j的引用，只是把k的值改变成为6。

由于k是i的引用，所以i的值也变成了6。

inti=5;

intj=6;

|

int&k=i;

k=j;//k和i的值都变成了6;

上面的程序看起来象在玩文字游戏，没有体现出引用的价值。

引用的主要功能是传递函数的参数和返回值。

C++语言中，函数的参数和返回值的传递方式有三种：

值传递、指针传递和引用传递。

以下是“值传递”的示例程序。

由于Func1函数体内的x是外部变量n的一份拷贝，改变x的值不会影响n,所以n的值仍然是0。

voidFunc1（intx）

{

x=x+10;

}

…

intn=0;

Func1（n）;

】

cout<<“n=”<

以下是“指针传递”的示例程序。

由于Func2函数体内的x是指向外部变量n的指针，改变该指针的内容将导致n的值改变，所以n的值成为10。

voidFunc2（int*x）

{

（*x）=（*x）+10;

}

…

intn=0;

Func2（&n）;

cout<<“n=”<

:

以下是“引用传递”的示例程序。

由于Func3函数体内的x是外部变量n的引用，x和n是同一个东西，改变x等于改变n，所以n的值成为10。

voidFunc3（int&x）

{

x=x+10;

}

…

intn=0;

Func3（n）;

cout<<“n=”<

\

对比上述三个示例程序，会发现“引用传递”的性质象“指针传递”，而书写方式象“值传递”。

5附录

变量类型定义

类型

规则

范例

bool（BOOL）

用b开头

bIsParent

byte（BYTE）

—

用by开头

byFlag

short（SHORT）

用n开头

nFileLen

int（INT）

用n开头

nStepCount

long（LONG）

用l开头

lSize

、

char（CHAR）

用ch开头

chCount

unsignedshort（WORD）

用w开头

wLength

unsignedlong（DWORD）

用dw开头

dwBroad

void（VOID）

用v开头

vVariant

用0结尾的字符串

用sz开头

szFileName

LPCSTR（LPCTSTR）

用str开头

strString

HANDLE（HINSTANCE）

用h开头

hHandle

struct

用blk开头

blkTemplate

BYTE*

用pb开头

pbValue

WORD*

用pw开头

pwValue

LONG*

用pl开头

plValue