eccc语言
‘壹’ c语言求助：请编写一个字符串压缩程序，将字符串中连续出席的重复字母进行压缩，并输出压缩后的字符串。
#include <stdio.h>
void stringZip(const char
*pInputStr, long lInputLen, char *pOutputStr)
{ int n=1;
char c,*p1=pInputStr,*p2=pOutputStr;
while(*p1)
{
c=*(p1++);
while(*p1==c){n++;p1++;}
if(n>1)
{
if(n>999){*(p2++)=48+n/1000; n/=10;}
if(n>99){*(p2++)=48+n/100; n/=10;}
if(n>9){*(p2++)=48+n/10; n/=10;}
*(p2++)=48+n;
}
*(p2++)=c;
n=1;
}
*p2=' ';
}
void main()
{ char s1[200],s2[200];
gets(s1);
stringZip(s1,strlen(s1),s2);
puts(s2);
}
‘贰’ 求一个基于openssl写的ecc曲线的源代码
下面的例子生成两对ECC密钥，并用它做签名和验签，并生成共享密钥。
#include <string.h>
#include <stdio.h>
#include <openssl/ec.h>
#include <openssl/ecdsa.h>
#include <openssl/objects.h>
#include <openssl/err.h>
int main()
{
EC_KEY *key1,*key2;
EC_POINT *pubkey1,*pubkey2;
EC_GROUP *group1,*group2;
int ret,nid,size,i,sig_len;
unsigned char*signature,digest[20];
BIO *berr;
EC_builtin_curve *curves;
int crv_len;
char shareKey1[128],shareKey2[128];
int len1,len2;
/* 构造EC_KEY数据结构 */
key1=EC_KEY_new();
if(key1==NULL)
{
printf("EC_KEY_new err!\n");
return -1;
}
key2=EC_KEY_new();
if(key2==NULL)
{
printf("EC_KEY_new err!\n");
return -1;
}
/* 获取实现的椭圆曲线个数 */
crv_len = EC_get_builtin_curves(NULL, 0);
curves = (EC_builtin_curve *)malloc(sizeof(EC_builtin_curve) * crv_len);
/* 获取椭圆曲线列表 */
EC_get_builtin_curves(curves, crv_len);
/*
nid=curves[0].nid;会有错误，原因是密钥太短
*/
/* 选取一种椭圆曲线 */
nid=curves[25].nid;
/* 根据选择的椭圆曲线生成密钥参数group */
group1=EC_GROUP_new_by_curve_name(nid);
if(group1==NULL)
{
printf("EC_GROUP_new_by_curve_name err!\n");
return -1;
}
group2=EC_GROUP_new_by_curve_name(nid);
if(group1==NULL)
{
printf("EC_GROUP_new_by_curve_name err!\n");
return -1;
}
/* 设置密钥参数 */
ret=EC_KEY_set_group(key1,group1);
if(ret!=1)
{
printf("EC_KEY_set_group err.\n");
return -1;
}
ret=EC_KEY_set_group(key2,group2);
if(ret!=1)
{
printf("EC_KEY_set_group err.\n");
return -1;
}
/* 生成密钥 */
ret=EC_KEY_generate_key(key1);
if(ret!=1)
{
printf("EC_KEY_generate_key err.\n");
return -1;
}
ret=EC_KEY_generate_key(key2);
if(ret!=1)
{
printf("EC_KEY_generate_key err.\n");
return -1;
}
/* 检查密钥 */
ret=EC_KEY_check_key(key1);
if(ret!=1)
{
printf("check key err.\n");
return -1;
}
/* 获取密钥大小 */
size=ECDSA_size(key1);
printf("size %d \n",size);
for(i=0;i<20;i++)
memset(&digest[i],i+1,1);
signature=malloc(size);
ERR_load_crypto_strings();
berr=BIO_new(BIO_s_file());
BIO_set_fp(berr,stdout,BIO_NOCLOSE);
/* 签名数据，本例未做摘要，可将digest中的数据看作是sha1摘要结果 */
ret=ECDSA_sign(0,digest,20,signature,&sig_len,key1);
if(ret!=1)
{
ERR_print_errors(berr);
printf("sign err!\n");
return -1;
}
/* 验证签名 */
ret=ECDSA_verify(0,digest,20,signature,sig_len,key1);
if(ret!=1)
{
ERR_print_errors(berr);
printf("ECDSA_verify err!\n");
return -1;
}
/* 获取对方公钥，不能直接引用 */
pubkey2 = EC_KEY_get0_public_key(key2);
/* 生成一方的共享密钥 */
len1=ECDH_compute_key(shareKey1, 128, pubkey2, key1, NULL);
pubkey1 = EC_KEY_get0_public_key(key1);
/* 生成另一方共享密钥 */
len2=ECDH_compute_key(shareKey2, 128, pubkey1, key2, NULL);
if(len1!=len2)
{
printf("err\n");
}
else
{
ret=memcmp(shareKey1,shareKey2,len1);
if(ret==0)
printf("生成共享密钥成功\n");
else
printf("生成共享密钥失败\n");
}
printf("test ok!\n");
BIO_free(berr);
EC_KEY_free(key1);
EC_KEY_free(key2);
free(signature);
free(curves);
return 0;
}
‘叁’ 姹傝茶ВECC锛 128浣嶆暟鎹浣嶏纴9浣嶆牎楠屼綅镄勭畻娉
ECC锛圗rror Correction Code锛夋槸涓绉岖敤𨱒ユ娴嫔拰绾犳ｅ唴瀛树腑镄勬暟鎹阌栾镄勬妧链锛屽畠鍙浠ユ彁楂樼郴缁熺殑鍙闱犳у拰绋冲畾镐с侲CC浣跨敤涓绉嶆洿楂樼骇镄勫囧伓镙￠獙鏂规硶锛屽嵆瀵规疮64浣嶆暟鎹鐢熸垚7浣嶆牎楠屼綅锛岀劧钖庢牴鎹杩欎簺镙￠獙浣嶆潵鍒ゆ柇鏁版嵁鏄钖﹀彂鐢熶简阌栾锛屼互鍙婂备綍淇澶嶉敊璇銆
鐢–璇瑷缂栧啓涓涓128浣嶆暟鎹浣嶏纴9浣嶆牎楠屼綅镄凟CC绠楁硶锛岄渶瑕佷互涓嫔嚑涓姝ラわ细
瀹氢箟涓涓缁撴瀯浣掳纴琛ㄧず涓涓128浣岖殑鏁版嵁瀛楋纴浠ュ强涓涓9浣岖殑镙￠獙瀛椼傛垜浠鍙浠ヤ娇鐢ㄤ竴涓闀垮害涓4镄勬棤绗﹀彿鏁村瀷鏁扮粍𨱒ュ瓨鍌ㄦ暟鎹瀛楋纴姣忎釜鍏幂礌鍗32浣嶏纴鍏辫128浣嶃傛垜浠鍙浠ヤ娇鐢ㄤ竴涓镞犵﹀彿瀛楃︽潵瀛桦偍镙￠獙瀛楋纴鍗8浣嶏纴鍐嶅姞涓娄竴涓甯冨皵鍊兼潵琛ㄧず绗9浣嶏纴鍏辫9浣嶃
瀹氢箟涓涓鍑芥暟锛屾牴鎹缁椤畾镄勬暟鎹瀛楃敓鎴愬瑰簲镄勬牎楠屽瓧銆傛垜浠鍙浠ヤ娇鐢ㄥ纾鎴栬繍绠楁潵璁＄畻姣忎竴浣岖殑濂囧伓镙￠獙鍊硷纴铹跺悗灏呜繖浜涘肩粍钖堟垚涓涓镙￠獙瀛椼
瀹氢箟涓涓鍑芥暟锛屾牴鎹缁椤畾镄勬暟鎹瀛楀拰镙￠獙瀛楁娴嬫槸钖︽湁阌栾鍙戠敓銆傛垜浠鍙浠ヤ娇鐢ㄥ纾鎴栬繍绠楁潵姣旇缉鏁版嵁瀛楀拰镙￠獙瀛椾腑镄勬疮涓浣嶏纴濡傛灉链変笉钖岋纴鍒栾存槑链夐敊璇鍙戠敓銆傛垜浠鍙浠ヤ娇鐢ㄤ竴涓鏁村瀷鍙橀噺𨱒ヨ板綍阌栾鍙戠敓镄勪綅缃锛屽傛灉娌℃湁阌栾锛屽垯杩斿洖-1銆
瀹氢箟涓涓鍑芥暟锛屾牴鎹缁椤畾镄勬暟鎹瀛楀拰阌栾浣岖疆淇澶嶉敊璇銆傛垜浠鍙浠ヤ娇鐢ㄥ纾鎴栬繍绠楁潵缈昏浆鏁版嵁瀛椾腑鍑洪敊镄勯偅涓浣嶏纴浠庤屾仮澶嶆ｇ‘镄勫笺
1、数据加密的基本过程就是对原来为明文的文件或数据按某种算法进行处理，使其成为不可读的一段代码，通常称为“密文”，使其只能在输入相应的密钥之后才能显示出本来内容，通过这样的途径来达到保护数据不被非法人窃取、阅读的目的。
2、常见加密算法
DES（Data Encryption Standard）：数据加密标准，速度较快，适用于加密大量数据的场合；
3DES（Triple DES）：是基于DES，对一块数据用三个不同的密钥进行三次加密，强度更高；
RC2和 RC4：用变长密钥对大量数据进行加密，比 DES 快；
IDEA（International Data Encryption Algorithm）国际数据加密算法：使用 128 位密钥提供非常强的安全性；
RSA：由 RSA 公司发明，是一个支持变长密钥的公共密钥算法，需要加密的文件块的长度也是可变的；
DSA（Digital Signature Algorithm）：数字签名算法，是一种标准的 DSS（数字签名标准）；
AES（Advanced Encryption Standard）：高级加密标准，是下一代的加密算法标准，速度快，安全级别高，目前 AES 标准的一个实现是 Rijndael 算法；
BLOWFISH，它使用变长的密钥，长度可达448位，运行速度很快；
其它算法，如ElGamal、Deffie-Hellman、新型椭圆曲线算法ECC等。
比如说，MD5，你在一些比较正式而严格的网站下的东西一般都会有MD5值给出，如安全焦点的软件工具，每个都有MD5。
3、例程：
#include<stdio.h>
#include<process.h>
#include<conio.h>
#include<stdlib.h>
#definemaxim65537
#definefuyi65536
#defineone65536
#defineround8
unsignedintinv(unsignedintxin);
unsignedintmul(unsignedinta,unsignedintb);
voidcip(unsignedintIN[4],unsignedintOUT[4],unsignedintZ[7][10]);
voidkey(unsignedintuskey[9],unsignedintZ[7][10]);
voidde_key(unsignedintZ[7][10],unsignedintDK[7][10]);
voidmain()
{
inti,j,k,x;
unsignedintZ[7][10],DK[7][10],XX[5],TT[5],YY[5];
unsignedintuskey[9];
FILE*fpout,*fpin;
printf(" InputKey");
for(i=1;i<=8;i++)
scanf("%6u",&uskey[i]);
for(i=0;i<9;i++)
uskey[i]=100+i*3;
key(uskey,Z);/*产生加密子密钥*/
de_key(Z,DK);/*计算解密子密钥*/
if((fpin=fopen("ekey.txt","w"))==NULL)
{
printf("cannotopenfile!");
exit(EXIT_FAILURE);
}
for(i=0;i<7;i++)
{
for(j=0;j<10;j++)
fprintf(fpin,"%6u",Z[i][j]);
fprintf(fpin," ");
}
fclose(fpin);
/*XX[1..5]中为明文*/
for(i=0;i<4;i++)XX[i]=2*i+101;
clrscr();
printf("Mingwen%6u%6u%6u%6u ",XX[0],XX[1],XX[2],XX[3]);
if((fpin=(fopen("ideaming.txt","w")))==NULL)
{printf("cannotopenfile!");
exit(EXIT_FAILURE);
}
fprintf(fpin,"%6u,%6u,%6u,%6u ",XX[0],XX[1],XX[2],XX[3]);
fclose(fpin);
for(i=1;i<=30000;i++)
cip(XX,YY,Z);/*用密钥Z加密XX中的明文并存在YY中*/
printf(" Mingwen%6u%6u%6u%6u ",YY[0],YY[1],YY[2],YY[3]);
if((fpin=fopen("ideamiwn.txt","w"))==NULL)
{
printf("cannotopenfile!");
exit(EXIT_FAILURE);
}
fprintf(fpout,"%6u%6u%6u%6u ",YY[0],YY[1],YY[2],YY[3]);
{
printf("cannotopenfile!");
exit(EXIT_FAILURE);
}
fprintf(fpout,"%6u%6u%6u%6u ",YY[0],YY[1],YY[2],YY[3]);
fclose(fpout);
for(i=1;i<=30000;i++)
cip(YY,TT,DK);/*encipherYYtoTTwithKeyDK*/
printf(" JieMi%6u%6u%6u%6u ",TT[0],TT[1],TT[2],TT[3]);
if((fpout=fopen("dideaout.txt","w"))==NULL)
{
printf("cannotopenfile!");
exit(EXIT_FAILURE);
}
fprintf(fpout,"%6u%6u%6u%6u ",TT[0],TT[1],TT[2],TT[3]);
fclose(fpout);
}
/*此函数执行IDEA算法中的加密过程*/
voidcip(unsignedintIN[4],unsignedintOUT[4],unsignedintZ[7][10])
{
unsignedintr,x1,x2,x3,x4,kk,t1,t2,a;
x1=IN[0];x2=IN[1];x3=IN[2];x4=IN[3];
for(r=1;r<=8;r++)
{
/*对64位的块进行分组运算*/
x1=mul(x1,Z[1][r]);x4=mul(x4,Z[4][r]);
x2=x2+Z[2][r]&one;x3=(x3+Z[3][r])&one;
/*MA结构的函数*/
kk=mul(Z[5][r],(x1^x3));
t1=mul(Z[6][r],(kk+(x2^x4))&one;
/*随机变换PI*/
x1=x1^t1;x4=x4^t2;a=x2^t2;x2=x3^t1;x3=a;
}
/*输出转换*/
OUT[0]=mul(x1,Z[1][round+1]);
OUT[3]=mul(x4,Z[1][round+1]);
OUT[1]=(x3+Z[2][round+1])&one;
OUT[2]=(x2+Z[3][round+1])&one;
}
/*用高低算法上实现乘法运算*/
unsignedintmul(unsignedinta,unsignedintb)
{
longintp;
longunsignedq;
if(a==0)p=maxim-b;
elseif(b==0)p=maxim-a;
else
{
q=(unsignedlong)a*(unsignedlong)b;
p=(q&one)-(q>>16);
if(p<=0)p=p+maxim;
{
return(unsigned)(p&one);
}
/*通过Euclideangcd算法计算xin的倒数*/
unsignedintinv(unsignedintxin)
{
longn1,n2,q,r,b1,b2,t;
if(xin==0)
b2=0;
else
{n1=maxim;n2=xin;b2=1;b1=0;
do{
r=(n1%n2);q=(n1-r)/n2;
if(r==0)
if(b2<0)b2=maxim+b2;
else
{n1=n2;n2=r;
t=b2;
b2=b1-q*b2;b1=t;
}
}while(r!=0);
}
return(unsignedlongint)b2;
}
/*产生加密子密钥Z*/
voidkey(unsignedintuskey[9],unsignedintZ[7][10])
{
unsignedintS[54];
inti,j,r;
for(i=1;i<9;i++)
S[i-1]=uskey[i];
/*shifts*/
for(i=8;i<54;i++)
{
if(i+2)%8==0)/*对于S[14],S[22],...进行计算*/
S[i]=((S[i-7]<<0)^(S[i-14]>>7)&one;
elseif((i+1)%8==0)/*对于S[15],S[23],...进行计算*/
S[i]=((S[i-15]<<9)^(S[i-14]>>7)&one;
else
S[i]=((S[i-7]<<9)^(S[i-6]>>7)&one;
}
/*取得子密钥*/
for(r=1;r<=round+1;r++)
for(j=1;j<7;j++)
Z[j][r]=S[6*(r-1)+j-1];
}
/*计算解子密钥DK*/
voidde_key(unsignedintZ[7][10],unsignedintDK[7][10])
{
intj;
for(j=1;j<=round+1;j++)
{DK[1][round-j+2]=inv(Z[1][j]);
DK[4][round-j+2]=inv(Z[4][j]);
if(i==1|j==round+1)
{
DK[2][round-j+2]=(fuyi-Z[2][j])&one;
DK[3][round-j+2]=(fuyi-Z[3][j])&one;
}
else
{
DK[2][round-j+2]=inv(Z[3][j]);
DK[3][round-j+2]=inv(Z[2][j]);
}
}
for(j=1;j<=round+1;j++)
{
DK[5][round-j+2]=inv(Z[5][j]);
DK[6][round-j+2]=inv(Z[6][j]);
}
}
‘伍’ c语言常用函数有哪些主要掌握的要点是什么
标准头文件包括：
<asset.h> <ctype.h> <errno.h> <float.h>
<limits.h> <locale.h> <math.h> <setjmp.h>
<signal.h> <stdarg.h> <stddef.h> <stdlib.h>
<stdio.h> <string.h> <time.h>
一、标准定义（<stddef.h>）
文件<stddef.h>里包含了标准库的一些常用定义，无论我们包含哪个标准头文件，<stddef.h>都会被自动包含进来。
这个文件里定义：
l 类型size_t （sizeof运算符的结果类型，是某个无符号整型）；
l 类型ptrdiff_t（两个指针相减运算的结果类型，是某个有符号整型）；
l 类型wchar_t （宽字符类型，是一个整型，其中足以存放本系统所支持的所有本地环境中的字符集的所有编码值。这里还保证空字符的编码值为0）；
l 符号常量NULL （空指针值）；
l 宏offsetor （这是一个带参数的宏，第一个参数应是一个结构类型，第二个参数应是结构成员名。
offsetor(s,m)求出成员m在结构类型t的变量里的偏移量）。
注：其中有些定义也出现在其他头文件里（如NULL）。
二、错误信息（<errno.h>）
<errno.h>定义了一个int类型的表达式errno，可以看作一个变量，其初始值为0，一些标准库函数执行中出错时将它设为非0值，但任何标准库函数都设置它为0。
<errno.h>里还定义了两个宏EDOM和ERANGE，都是非0的整数值。数学函数执行中遇到参数错误，就会将errno置为EDOM，如出现值域错误就会将errno置为ERANGE。
三、输入输出函数（<stdio.h>）
文件打开和关闭：
FILE *fopen(const char *filename, const char *mode);
int fclose(FILE * stream);
字符输入输出：
int fgetc(FILE *fp);
int fputc(int c, FILE *fp);
getc和putc与这两个函数类似，但通过宏定义实现。通常有下面定义：
#define getchar() getc(stdin)
#define putchar(c) putc(c, stdout)
int ungetc(int c, FILE* stream);//把字符 c 退回流 stream
格式化输入输出：
int scanf(const char *format, ...);
int printf(const char *format, ...);
int fscanf(FILE *stream, const char *format, ...);
int fprintf(FILE *stream, const char *format, ...);
int sscanf(char *s, const char *format, ...);
int sprintf(char *s, const char *format, ...);
行式输入输出：
char *fgets(char *buffer, int n, FILE *stream);
int fputs(const char *buffer, FILE *stream);
char *gets(char *s);
int puts(const char *s);
直接输入输出：
size_t fread(void *pointer, size_t size, size_t num, FILE *stream);
size_t fwrite(const void *pointer, size_t size, size_t num, FILE *stream);
‘陆’ c语言伪码书写的规范是什么
伪码书写可以参考C代码规范。
1.
1.1符号命名规则
1.1.1符号名包括模块名、常量名、标号名、子程序名等。这些名字应该能反映它所代表的实际东西，具有一定的意义，使其能够见名知义，有助于对程序功能的理解。命名采用匈牙利命名法。规则如下：
(1)所有宏定义、枚举常数和const变量，用大写字母命名。在复合词里用下划线隔开每个词。
(2)复合词中每个单词的第一个字母大写。除了规则5.1.1.1以外，避免使用下划线。
(3)类、类型定义和枚举型名的第一个字母大写。
(4)函数名是复合词的，第一个词采用全部小写，随后每个单词采用第一个字母大写，其它字母小写方式；如果是单个词的，采用全部小写方式。
(5)循环变量可采用i, j, k等，不受上述规则限制。
(6) 类的成员变量应采用m_开头。
(7) 全局变量词头为g_ 。
(8) 临时变量词头为tmp_ 。
(9) 对结构体内的变量命名, 遵循变量的具体含义命名原则
(10)用小写字母的前缀表示变量的类型，前缀的下一个字母用大写。
表 1
词头 类型 词头 类型
ch char l long
i integer u unsigned
b boolean p pointer
f float lp long pointer
d double s string
st structure sz ASCII string
by byte n short int
H handle x,y 分别为x,y坐标
dw DWORD fn function
表 2
词头 变量名 词头 变量名
task task sig signal
sb binary semaphores wd watchdog
sm mutual exclusion tm timer
sc counting semaphores msg message
pipe pipe
例：
#define ARRAY_SIZE 24 /*规则5.1.1.1*/
int g_iFlag;
class MyClass /*规则5.1.1.3*/
{
};
void someFunc( ) /*规则5.1.1.2和5.1.1.4*/
{
int nArray[ARRAY_SIZE];
unsigned char uchByte;
char szName[ ];
char *pszName = szName;
}
(11)有些词头（如p和u）可以和其它词头组合。
例：WDOG_ID wdId;
WDOG_ID g_wdId; /*全局watchdog Id，故以g_开头*/
1.1.2名字的长度一般不要过长或过短。过长的名字会增加工作量，使程序逻辑流程变得模糊；过短的名字无法表达符号的实际意义。约定长度范围：3-31；
1.2数据和函数说明
1.2.1数据说明次序应当规范化，使数据属性容易查找，也有利于测试、排错和维护。说明的先后次序应固定，应按逻辑功能排序，逻辑功能块内建议采用下列顺序：整型说明、实型说明、字符说明、逻辑量说明。
1.2.2如果设计了一个复杂的数据结构，应当通过注释对其变量的含义、用途进行说明。
1.2.3在函数的声明中使用异常声明。
如：void f() throw(toobig, toosmall, divzero);
在声明一个函数时，将它所抛出的异常列出，便于函数的使用者了解可能会发生哪些异常。
1.3 程序注释
1.3.1程序注释是程序员与日后的程序读者之间通信的重要手段之一，注释分为文件注释、函数注释和功能注释。
1.3.2正规程序的注释应注意：
——注释行的数量占到整个源程序的1/3到1/2。
1.3.3文件注释位于整个源程序的最开始部分，注释后空两行开始程序正文。它包括：
——程序标题。
——目的、功能说明。
——文件作者、最后修改日期等说明。
例：
./********************************************************************
（空一行）
标题: Demo.c
功能: 测试VxWorks的各种系统调用.
说明:
该程序测试各种VxWorks的系统调用函数。包括任务（taks）的创建、挂起及任务间通过信号灯实现同步，通过消息队列 进行通讯。
程序创建了两个任务：一个高优先级的任务和一个低优先级的任务。两个任务间通过一个二进制的信号灯进行同步，通过消息队列进行通讯。
当前版本： x.x
修改信息： 2000.06.05 John， Initial Version
2000.07.05 Tom， Bug xxxx fixed
**************************************************************/
(空2行，开始程序正文)
1.3.4 函数注释通常置于每函数或过程的开头部分，它应当给出函数或过程的整体说明对于理解程序本身具有引导作用。一般包括如下条目：
——模块标题。
——有关本模块功能和目的的说明。
——调用格式
——接口说明：包括输入、输出、返回值、异常。
——算法。如果模块中采用了一些复杂的算法。
例：
file://（/注释开头应和上一函数空两行）
（注释开头与上一函数最后一行间隔两行）
/********************************************************************
标题：assignmentComplete
功能：BSC=>MSC消息生成函数，生成assignment_complete指配完成消息(BSMAP消息) .
格式：
int assignmentComplete(int iCellId, int iServiceChannnelNum, char *pszMSGData) throw(exception1, exception2)
输入：
int iCellId: MS所在的小区识别
iCellId取值：0x00-——0xff
int iServiceChannnelNum：MS所占的业务信道号码
输出：
char * pszMSGData：指配完成消息数据
返回值: 0x00正常
异常：exception1异常情况1, exception2异常情况2
********************************************************************/
( 注释后直接开始程序正文，不空行。)
1.3.5功能性注释嵌在源程序体中，用于描述其后的语句或程序段做什么工作，也就是解释下面要做什么，或是执行了下面的语句会怎么样。而不要解释下面怎么做，因为解释怎么做常常与程序本身是重复的。
例：
/*把 amount 加到 total中*/
total = amount + total;
这样的注释仅仅是重复了下面的程序，对于理解它的工作并没有什么作用。而下面的注释，有助于读者理解。
/*将每月的销售额amount加到年销售额total中*/
total = amount + total;
1.4 函数编写应尽可能短小精悍，一般不超过两屏，以便于调试和理解。
1.5语句结构
为保证语句结构的清晰和程序的可读性，在编写软件程序时应注意以下几个方面的问题：
——在一行内只写一条语句，并采用空格、空行和移行保证清楚的视觉效果。
——每一个嵌套的函数块，使用一个TAB缩进（可以设定为4个空格），大括号必须放在条件语句的下一行，单独成一行，便于匹对：
如，有一段程序如下：
for(i=1;i<n-1;i++){ t=1; for(j=i+1;j<n;j++){
if(a[j]<a[t] ) t=j; if(t!=i ){work=a[t];a[t]=a[I];a[I]=work;}}}
应写为
for( i=1; i<n-1; i++)
{
t=1;
for(j = i+1; j<n; j++)
{
if(a[i]<a[j])
t=j;
if(t!=1)
{ .5.
Q/ECC/BJ 010—2001
work=a[t];
a[t]=a[i];
a[i]=work;
}
}
}
——文件之中不得存在无规则的空行，比如说连续十个空行。
一般来讲函数与函数之间的空行为2-3行；
在函数体内部，在逻辑上独立的两个函数块可适当空行，一般为1-2行。
——程序编写首先应考虑清晰性，不要刻意追求技巧性而使得程序难以理解。
——每行长度尽量避免超过屏幕宽度，应不超过80个字符。
——除非对效率有特殊要求，编写程序要作到清晰第一，效率第二。
——尽可能使用函数库。
——尽量用公共过程或子程序去代替重复的功能代码段。要注意，这个代码应具有一个独立的功能，不要只因代码形式一样便将其抽出组成一个公共过程或子程序。
——使用括号清晰地表达算术表达式和逻辑表达式的运算顺序。如将 x=a*b/c*d 写成 x=(a*b/c)*d可避免阅读者误解为x=(a*b)/(c*d)。
——避免不必要的转移。
——避免采用过于复杂的条件测试。
——避免过多的循环嵌套和条件嵌套。
——建议不要使用 *=，^=, /=等运算符。
——一个函数不要超过200行。一个文件应避免超过2000行。
——尽量避免使用go to语句。
——避免采用多赋值语句，如x = y = z ;
——不鼓励采用?:操作符，如z = (a>b)?a:b;
——不要使用空的if else 语句。如
if(cMychar >= ‘A’)
if(cMychar <= ‘Z’)
printf(“This is a letter \n”);
else
printf(“This is not a letter \n”);
else到底是否定哪个if容易引起误解。可通过加{}避免误解。
——尽量减少使用“否定”条件的条件语句。如：
把 if( !( (cMychar<’0’) || (cMychar>’9’) ) )
改为if( (cMychar>=’0’) && (cMychar<=’9’) )