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

}

今天的文章HEW中有效的编程技术–笔记分享到此就结束了，感谢您的阅读。

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至举报，一经查实，本站将立刻删除。
如需转载请保留出处：http://bianchenghao.cn/63126.html

HEW中有效的编程技术–笔记

相关推荐

发表回复