HEW中有效的编程技术
有效的编程技术
１． 为增进 ROM 的效率和执行速度，可用 1 字节大小来代表的数据，应被声明为字符 / 无符号字符 (char/unsigned char) 类型。
２． 为增进目标的效率和执行速度，任何具有正数值的变量应被声明为无符号。
３． 禁止冗余类型 转换
、 通过 确保 在相同大小的数据项目之间执行操作，可增进 ROM 的效率和执行速度。
４． 使用
const 限 定符 、 保持 值不变的 初 始化数据应被列为常数以节 省 RAM 区域 。
已初 始化的数据项目经常可能在值上变更。 这些数据项目于连接期间在 ROM 上 分配 ，并在程序执行 开 始时被复 制 到 RAM ， 导致 它 们 同时在 ROM 和 RAM 区域内 被 分配 。 在程序执行的过程中 保持 值不变的数据项目可被列为常数，以使它 们只 在 ROM 区域内 被 分配 。
Eg: unsigned char a[5]={1, 2, 3, 4, 5};
const unsigned char a[5]={1, 2, 3, 4, 5}; // 优化后
在优化前，除了 ROM 以外，程序 还 需要在 RAM 为 分配 目标大小表中所列 出 的数据 区域 大小。
５． 使用一 致 的变量大小，在 循环 语句中作 比较 时，可使用 统 一的变量大小来 消 除对扩展代码的需要，并缩减所产生的代码大小。
6 ． 将
in-file 函数指定为 静态 函数， 只 在一个 文 件中使用的函数应被指定为 静态
(static) 。指定为 静态 的函数若不被外 部 函数所 调 用，则将被 删 除。 当 为 内联 扩展指定时，这些函数 也 将被 删 除，以增进大小效率。
7 ． 统 一 公 用表达式
， 通过在 多 个 算 术表达式中 统 一 公 用 组 件，可增进 ROM 的效率和执行速度。
Eg: （优化前的 C 语言程序）
unsigned char a,b,w,x,y,z;
void func(void)
{
a=x+y+z;
b=x+y+w;
}
（优化后的 C 语言程序）
unsigned char a,b,w,x,y,z;
void func(void)
{
unsigned char tmp;
tmp=x+y;
a=tmp+z;
b=tmp+w;
}
8. 增进条件决定 , 通过 评估 一 次 操作中的相似条件表达式来增进 ROM 的效率。
（优化前的 C 语言程序）
unsigned char a,b;
unsigned char func(void)
{
if (!a) return(0);
if (a&&!b) return(0);
return(1);
}
（优化后的 C 语言程序）
unsigned char a,b;
unsigned char func(void)
{
if (a&&b) return(1);
else return(0);
}
9. 使用 替换 值的条件决定
当 在条件表达式中对决定语句使用 替换 值时，可通过将 赋 值语句 视 为条件决定语句来增进 ROM 的效率。
（优化前的 C 语言程序）
char *s,*d;
void func(void)
{
while(*s){
*d++ = *s++;
}
*d++ = *s++;
}
（优化后的 C 语言程序）
char *s,*d;
void func(void)
{
while(*d++ = *s++);
}
10. 使用 合适 的运 算 法
如 果 算 术表达式 包含 常用术语，应将这些术语 析出 以缩减执行 算 术操作的 次 数。 这可同时增进 ROM 的效率和执行速度。
解 决 三阶 方程式。
（优化前的 C 语言程序）
unsigned char a,b,c,d,x,y;
void func(void)
{
y=a*x*x*x+b*x*x+c*x+d;
}
（优化后的 C 语言程序）
unsigned char a,b,c,d,x,y;
void func(void)
{
y=x*(x*(a*x+b)+c)+d;
}
11. 使用 公 式
使用数 学公 式以缩减 面向算 法的编码技术中所需的 算 术操作 次 数。 这可同时增进 ROM 的效率和执行速度。
计 算 1 到 100 的 总 和。
（优化前的 C 语言程序）
unsigned int s;
unsigned int n=100;
void func(void)
{
unsigned int i;
for (s=0,i=1;i<=n;i++)
s+=i;
}
（优化后的 C 语言程序）
unsigned int s;
unsigned int n=100;
void func(void)
{
s=n*(n+1)>>1;
}
12. 使用本 地 变量
通过将可用作本 地 变量的 临 时变量 、循环 计数 器等 声明为本 地 变量，可增进 ROM 的效率和执行速度。
同 样地 ，在对本 地 变量执行操作前，可通过将 多 个 算 术表达式的普遍外 部 变量 分配给 本 地 变量来提高效率。
将变量
a 增 加 到变量
b、
c 和
d ；将结果存储在变量
b、
c 和
d 内 。
（优化前的 C 语言程序）
unsigned char a,b,c,d;
void func(void)
{
b+=a;
c+=a;
d+=a;
}
（优化后的 C 语言程序）
unsigned char a,b,c,d;
void func(void)
{
unsigned char wk;
wk=a;
b+=wk;
c+=wk;
d+=wk;
}
13. 将
f 分配给浮 点类型常数
在 浮 点 算 术操作 涉 及 包含 在 浮 点类型的可 分配 值 范围内 （ 7.0064923216240862e-46f 到 3.4028235677973364e+38f ）的常数的 情形 下，在数字值之 后分配 字 母“ f ” 以 消 除可能 转换 为 复式
(double) 类型的冗余类型 转换 。
（优化前的 C 语言程序）
float a,b;
void func(void)
{
a=b+1.0;
}
（优化后的 C 语言程序）
float a,b;
void func(void)
{
a=b+1.0f;
}
14. 指定 移位 操作中的常数
对于 移位 操作， 如 果 移位 计数是一个变量，编译程序将会 调 用运行时例程以处理操作。 如 果 移位 计数是一个常数，编译程序将不会 调 用可有效增进执行速度的运行时例程。
（优化前的 C 语言程序）
int data;
int sht=8;
void func(void)
{
data=data<<sht;
}
（优化后的 C 语言程序）
#define SHT 8
int data;
void func(void)
{
data=data<<SHT;
}
15. 使用 移位 操作
在进行 乘 法和 加 法运 算 时， 尽 可能使用 移位 操作。
（优化前的 C 语言程序）
int data,a;
void main()
{
a=data+data+data;
}
（优化后的 C 语言程序）
int data,a;
void main()
{
a=(data<<1)+data;
}
16. 统 一连 续
ADD 指令
在 遇 到连 续加 法代码时，编译程序将执行一 致 的优化。 要 充分利 用此优化，必须 尽 可能 地 将 加 法运 算 连 续 编码。
（优化前的 C 语言程序）
int a,b;
void main()
{
a+=10;
b=10;
a+=20;
}
（优化后的 C 语言程序）
int a,b;
void main()
{
b=10;
a+=10;
a+=20;
}
17. 循环 处理
通过使用减量计数 器 及将终止条件和零相 比 ，可增进 ROM 的效率和执行速度。
（优化前的 C 语言程序）
unsigned char a[10],b[10];
int i;
void func(void)
{
for(i=0; i<10; i++)
b[i]=a[i];
}
（优化后的 C 语言程序）
unsigned char a[10],b[10];
int i;
void func(void)
{
for(i=9; i>=0; i--)
b[i]=a[i];
}
18. 选 择 重复 控制 语句
如 果 循环 语句被执行 至少 一 次 ，应 该 使用
do-while 语句来将它编码以缩减 循环 计数决定的一 次 操作， 从 而增进 ROM 的效率和执行速度。
（优化前的 C 语言程序）
unsigned char a[10],len=10;
unsigned char p1[10],p2[10];
void func(void)
{
char i;
for (i=len; i>0; i--)
p1[i-1]=p2[i-1];
}
（优化后的 C 语言程序）
unsigned char a[10],len=10;
unsigned char p1[10],p2[10];
void func(void)
{
char i=len;
do{
p1[i-1]=p2[i-1];
} while(--i);
}
19. 将不变量表达式 从循环 的 内部移 到外 部
如 果 出现 在 循环内部 的不 等 在 循环 外 部 被定 义 ，不 等只 在 循环 的 开头 被 评估 ，这将缩减在 循环 中执行的指令数目。 结果执行速度 获 得增进
（优化前的 C 语言程序）
unsigned char a[10],b,c;
int i;
void func(void)
{
for (i=9; i>=0; i--)
a[i]=b+c;
}
（优化后的 C 语言程序）
unsigned char a[10],b,c;
int i;
void func(void)
{
unsigned char tmp;
tmp=b+c;
for (i=9; i>=0; i--)
a[i]=tmp;
}
20. 合 并 循环 条件
在 循环 条件相同 或 相似的 情形 下，可通过将它 们合 并来增进 ROM 的效率和执行速度。
（优化前的 C 语言程序）
int a[10],b[10];
void f(void)
{
int i,j;
for (i=0; i<10; i++)
a[i]=0;
for (j=0; j<10; j++)
b[j]=1;
}
（优化后的 C 语言程序）
int a[10],b[10];
void f(void)
{
int i;
for (i=0; i<10; i++){
a[i]=0;
b[i]=1;
}
}
21. 使用指 针 变量
如 相同变量（外 部 变量）被 屡次参 考 或 必须存取数 组元素 ， ROM 的效率和执行速度可通过使用指 针 变量来增进。
使用指 针 变量会生成 采 用有效率的 寻址 模式（ @Rn 、 @Rn+ 、 @-Rn ）的代码。
实例
将数 组
data2 的 元素 复 制 到数 组
data1 。
（优化前的 C 语言程序）
void func(int data1[],int data2[])
{
int i;
for (i=0; i<10; i++)
data1[i]=data2[i];
}
（优化后的 C 语言程序）
void func(int *data1,int *data2)
{
int i;
for (i=0; i<10; i++){
*data1=*data2;
data1++; data2++;
}
}
22. 确保 数据 兼容 性
数据项目以所声明的 顺 序 分配 。 通过有效指定数据项目声明的 顺 序以 消 除 虚 设存储 区 的生成，可增进使用 ROM 和 RAM 的效率。
实例
分配总 数 8 字节的数据。
（优化前的 C 语言程序）
char a;
long b;
char c;
short d;
（优化后的 C 语言程序）
char a;
char c;
long b;
short d;
23. 数据 初 始化的技术
要缩减程序大小，任何需要 初 始化的变量必须在声明时被 初 始化。
24. 统 一数 组元素 的 初 始化
在一些数 组元素 必须被 初 始化的 情况 下，通过将它 们分组 到结 构 以使它 们 可以在 单 一操作中被 初 始化，将可增进 ROM 的效率。
使用相应值对化数 组
a 、
b 和
c 进行 初 始化。
（优化前的 C 语言程序）
void f(void)
{
unsigned char a[]={0,1,2,3};
unsigned char b[]="abcdefg";
unsigned char c[]="ABCDEFG";
}
（优化后的 C 语言程序）
void f(void)
{
struct x{
unsigned char a[4];
unsigned char b[8];
unsigned char c[7];
} A
={0,1,2,3,"abcdefg","ABCDEFG"};
}
25. 将 参 数 传递 为结 构地址
未 被 分配 到 寄 存 器 的 参 数必须使用结 构 的 地址 来 传递 以缩减程序大小。
在需要大的 参 数和使用大量 参 数的 情况 下，必须在将 参 数 传递 到目标函数之前，将它 们 在结 构 中 分组 以缩减程序大小。 如 果 参 数被声明为结 构 的成 员 ，且结 构 的 起 始 地址 被 当 作 参 数 传递 到目标函数，接 收 函数将可 依 据接 收地址 来存取成 员 。
实例
将 长 类型数据
a 、
b 、
c 和
d 传递 到函数
func 。
（优化前的 C 语言程序）
void sub(long,long,long,long);
long a,b,c,d;
void func(void)
{
sub(a,b,c,d);
}
（优化后的 C 语言程序）
void sub(struct ctag *);
struct ctag{
long a;
long b;
long c;
long d;
}x;
void func(void)
{
sub(&x);
}
26. 将结 构分配给寄 存 器
在本 地 变量被 当 作结 构 使用时，必须声明成 员 以便可以将变量 直 接 分配 到 寄 存 器 。
实例
将结 构 数据 传递 到函数
func 。
（优化前的 C 语言程序）
struct ST {
char a;
short b;
char c;
}pst;
void main()
{
struct ST s;
s.a=pst.a+10;
s.b=s.a+s.c;
func(s);
}
（优化后的 C 语言程序）
struct ST {
short b;
char a;
char c;
}pst;
void main()
{
struct ST s;
s.a=pst.a+10;
s.b=s.a+s.c;
func(s);
}
27. 增进函数被定 义 的程序 位置
通过在同一 文 件中定 义 任何经常在模 块 中 调 用的函数，可能可以增进 ROM 的效率和执行速度。
实例
从 函数
func 和
func1 调 用函数
func2 。
（优化前的 C 语言程序）
extern int func2(void);
int ret;
void func(void)
{
int i;
i=func2();
ret = i;
}
void func1(void)
{
int i;
i=func2();
ret = i;
}
（优化后的 C 语言程序）
int ret;
int func2(void)
{
return 0;
}
void func(void)
{
int i;
i=func2();
ret = i;
}
void func1(void)
{
int i;
i=func2();
}
28. 宏调 用
在相同处理例程被定 义 为 宏 时，它 们 将会在被 调 用的 位置 进行 内联 扩展。 这将 消 除代码的生成和增进效率。
实例
调 用函数
abs 。
（优化前的 C 语言程序）
extern int a,b,c;
int abs(x)
int x;
{ return x>=0?x:-x; }
void f(void)
{
a=abs(b);
b=abs(c);
}
（优化后的 C 语言程序）
#define abs(x) ((x)>=0?(x):-(x))
extern int a,b,c;
void f(void)
{
a=abs(b);
b=abs(c);
}
29. 声明 原 型
具有 字符 类型 或 无符号字符 类型 参 数的函数，必须在被 调 用之前进行 原 型声明以 消 除冗余类型 转换 代码的 输出 。
实例
调 用具有 字符 类型 或 无符号字符 类型 参 数的函数
sub1 。
（优化前的 C 语言程序）
char a;
unsigned char b;
void func(void)
{
sub1(a,b);
}
（优化后的 C 语言程序）
void sub1(char, unsigned char);
char a;
unsigned char b;
void func(void)
{
sub1(a,b);
}
30. 尾递归 的优化
如 果函数进行了一个函数 调 用， 观察 函数 调 用是 否 可以 移动 到 调 用 源 函数的 尾端 。 这可同时增进 ROM 的效率和执行速度。
尾递归 优化会在 满足 以下所有条件 后 执行：
调 用 源 函数不会在 堆栈 上 放置 它的 参 数 或返回 值 地址 。
该 函数 调 用之 后即 是 RTS 指令。
实例
调 用函数
sub 并更 新 外 部 变量的值。
（优化前的 C 语言程序）
void g(void);
int a;
void main(void)
{
if (a==0) a++;
else{
g();
a+=2;
}
}
（优化后的 C 语言程序）
void g(void);
int a;
void main(void)
{
if (a==0) a++;
else{
a+=2;
g();
}
}
31. 增进 参 数 传递 的方式
要缩减代码大小，必须 调整参 数列 出 时的 顺 序以使 参 数之间没有间 隙 。
（优化前的 C 语言程序）
long rtn;
void func(char,short,char);
void main()
{
short a;
char b,c;
func(b,a,c);
}
void func(char x,short y,char z)
{
rtn=x*y+z;
}
（优化后的 C 语言程序）
long rtn;
void func(char,char,short);
void main()
{
short a;
char b,c;
func(b,c,a);
}
void func(char x,char y,short z)
{
rtn=x*y+z;
}
32. 将 切换 语句重 写 为表
如 果 case 语句所执行的 与
switch 关联 的处理任务是相似的，
switch 语句必须使用一个表来编码以缩减目标大小。
实例
根 据函数
a 的值 转移 到一个函数。
（优化前的 C 语言程序）
extern void f1(void);
extern void f2(void);
extern void f3(void);
extern void f4(void);
extern void f5(void);
extern int a;
void sub(void)
{
switch(a){
case 0:f1();break;
case 1:f2();break;
case 2:f3();break;
case 3:f4();break;
case 4:f5();break;
}
}
（优化后的 C 语言程序）
extern void f1(void);
extern void f2(void);
extern void f3(void);
extern void f4(void);
extern void f5(void);
extern int a;
void sub(void)
{
static int (*key[5])()=
{f1,f2,f3,f4,f5};
(*key[a])();
}
33. 编 写
Case 语句 跳转至 相同标 签 的程序
包含 相同表达式的
case 语句必须 组合 在一 起 ，以减 少转移 指令的数目并缩减目标大小。
（优化前的 C 语言程序）
long ll;
void func(void)
{
char c;
switch(c){
case 0: ll=0; break;
case 1: ll=0; break;
case 2: ll=1; break;
case 3: ll=1; break;
case 4: ll=2; break;
}
}
（优化后的 C 语言程序）
long ll;
void func(void)
{
char c;
switch(c){
case 0:
case 1: ll=0; break;
case 2:
case 3: ll=1; break;
case 4: ll=2; break;
}
}
34. 转移 到 直 接在指定语句下编码的函数
如 果函数 调 用 出现 在函数的 尾端 ，必须将 调 用目标函数 直 接 放置 在函数 调 用下 面 。
如 果 尾递归 优化正在进行，必须将 调 用目标函数 直 接 放置 在函数 调 用下 面 ，以 充分利 用此优化来产生 删 除函数 调 用代码的效果。由于 删 除了函数 调 用代码，程序的大小将会缩减而处理速度将会增 加 。
实例
从 函数
main 调 用函数
func 。
（优化前的 C 语言程序）
int a;
void func();
void func()
{
a++;
}
void main()
{
a=0;
func();
}
（优化后的 C 语言程序）
int a;
void func();
void main()
{
a=0;
func();
}
void func()
{
a++;
}
