|
EDA365欢迎您登录!
您需要 登录 才可以下载或查看,没有帐号?注册
x
1.static关键字7 N$ P( a- q$ F/ A8 t' X
这个关键字前面也有提到,它的作用是强大的。
b) Z" T- ^) `0 k; y: V1 V要对static关键字深入了解,首先需要掌握标准C程序的组成。
3 F0 M( q- {' D/ Z) }) g标准C程序一直由下列部分组成:$ d) o7 ^5 L1 G
1)正文段——CPU执行的机器指令部分,也就是你的程序。一个程序只有一个副本;只读,这是为了防止程序由于意外事故而修改自身指令;
2 _# [' X9 Y) d 2)初始化数据段(数据段)——在程序中所有赋了初值的全局变量,存放在这里。
+ ~7 Z! J$ c! A5 o 3)非初始化数据段(bss段)——在程序中没有初始化的全局变量;内核将此段初始化为0。& C- p' e2 o3 w3 t
注意:只有全局变量被分配到数据段中。
* v4 c4 I. }8 \0 A) \6 @3 } 4)栈——增长方向:自顶向下增长;自动变量以及每次函数调用时所需要保存的信息(返回地址;环境信息)。这句很关键,常常有笔试题会问到什么东西放到栈里面就足以说明。
& S. W, W3 M+ G6 M- } 5)堆——动态存储分配。# \4 F b9 |; _' A4 g" d8 \8 N
0 a( i, Q v1 I; u9 B
在嵌入式C语言当中,它有三个作用:
+ B6 Z9 h9 \, a4 o% v$ {作用一:在函数体,一个被声明为静态的变量在这一函数被调用过程中维持其值不变。# T: y( w y+ l4 N* k/ d3 w: a
这样定义的变量称为局部静态变量:在局部变量之前加上关键字static,局部变量就被定义成为一个局部静态变量。也就是上面的作用一中提到的在函数体内定义的变量。除了类型符外,若不加其它关键字修饰,默认都是局部变量。比如以下代码:
# O1 V1 L$ l( x; Xvoid test1(void)% y2 l' \! s$ t d
{ O* U* F0 `/ R J
unsigned char a;
0 y, u+ _0 S3 [7 `& @) v" U static unsigned char b;4 z4 X7 S% ^: @; h8 n0 O
…
9 y; U8 W2 p) g1 F$ @$ p8 d a++;
- U3 C$ [, e X" a! e9 D b++;) H. z* e" t7 ?, t* { d
}$ r p- j1 J3 @7 f5 u% K
在这个例子中,变量a是局部变量,变量b为局部静态变量。作用一说明了局部静态变量b的特性:在函数体,一个被声明为静态的变量(也就是局部静态变量)在这一函数被调用过程中维持其值不变。这句话什么意思呢?若是连续两次调用上面的函数test1:9 M) P/ ]- `# e* i2 Q; Y' y
void main(void)
3 C5 ^! a! O5 @9 R {
/ A" l, u) r2 A" B* f5 `9 {8 N …
. J, z- D7 Z/ C/ {; U test1();
" F# a& }3 c- |8 p( V test1();! l& U r3 [' o
…
+ L+ l8 `) q: ^0 E7 R$ K M }
r% s0 Q* |4 j. o然后使程序暂停下来,读取a和b的值,你会发现,a=1,b=2。怎么回事呢,每次调用test1函数,局部变量a都会重新初始化为0x00;然后执行a++;而局部静态变量在调用过程中却能维持其值不变。$ H0 P5 Z3 {. _ a: r
通常利用这个特性可以统计一个函数被调用的次数。
" Q2 Q2 n4 ]% b" s; ?声明函数的一个局部变量,并设为static类型,作为一个计数器,这样函数每次被调用的时候就可以进行计数。这是统计函数被调用次数的最好的办法,因为这个变量是和函数息息相关的,而函数可能在多个不同的地方被调用,所以从调用者的角度来统计比较困难。代码如下:: w8 y" b5 V* V& f% X2 X; W
# S- C8 s& G2 o8 U$ s# D
6 x' t& V8 V8 W1 ovoid count();3 M# C, s U8 z+ X2 q7 t9 L- u
int main()+ \5 [! D/ D- G% q* c
{+ M; u( e+ N4 J8 z& I! g
int i;
6 H: N) }/ B7 V4 I' o6 | for (i = 1; i <= 3; i++)& X6 d. d; Y3 ^+ `7 E
{
; |2 Y& ?7 Z8 G( T3 |- T1 O! n9 E count();
/ Y2 F' G J7 f" I/ \% d {
- [- h0 @7 O9 x" u4 P. |4 J return 0;5 B2 }% i i" [# A
}- ?, e- P) n2 T7 X' l+ N
void count()
) S. ?. a1 {) }( Q$ G$ k# z7 b{1 x9 D4 m) |! G! N, q, q
static num = 0;; e2 p! W- Z2 L: F( t" L
num++;
. m- X; G! K2 D! X, y9 ^& l1 @ printf(" I have been called %d",num,"times/n");# `. d. A3 v- Q
}9 ?7 b' ]" g2 v _2 G" r4 a
输出结果为:
2 K6 R: S! t: d# Y4 II have been called 1 times.% i/ v" T/ j6 a
I have been called 2 times.0 F# ~: Z1 o# g- m0 L$ g
I have been called 3 times.
A; g5 T9 R$ \
0 _- V! V$ ?5 u% w2 ~看一下局部静态变量的详细特性,注意它的作用域。
; H' f1 m( P' I* u* b 1)内存中的位置:静态存储区' j; Y7 _0 X* j6 n/ i3 a7 l1 }
2)初始化:未经初始化的全局静态变量会被程序自动初始化为0(自动对象的值是任意的,除非他被显示初始化)
% i0 I3 G# z; y 3)作用域:作用域仍为局部作用域,当定义它的函数或者语句块结束的时候,作用域随之结束。. ^8 B W2 e5 b8 K, `$ G
注:当static用来修饰局部变量的时候,它就改变了局部变量的存储位置,从原来的栈中存放改为静态存储区。但是局部静态变量在离开作用域之后,并没有被销毁,而是仍然驻留在内存当中,直到程序结束,只不过我们不能再对他进行访问。$ b. E3 Q+ W! X
0 _, }; ?+ Z7 ~; H% S! F0 @
作用二:在模块内(但在函数体外),一个被声明为静态的变量可以被模块内所用函数访问,但不能被模块外其它函数访问。它是一个本地的全局变量。
: K! Y2 d" T; K X9 ]1 a$ t% V2 Y这样定义的变量也称为全局静态变量:在全局变量之前加上关键字static,全局变量就被定义成为一个全局静态变量。也就是上述作用二中提到的在模块内(但在函数体外)声明的静态变量。
! \6 L9 e0 n+ a; S! B定义全局静态变量的好处:
% @, Y6 H7 g$ @0 p6 A9 i<1>不会被其他文件所访问,修改,是一个本地的局部变量。
; p& a: f0 Y4 k0 c& M$ Z; j<2>其他文件中可以使用相同名字的变量,不会发生冲突。
! t3 f) @4 {, n全局变量的详细特性,注意作用域,可以和局部静态变量相比较:
7 P" k& Z" n3 f0 }1)内存中的位置:静态存储区(静态存储区在整个程序运行期间都存在)$ j" m, M8 b7 [ _4 R
2)初始化:未经初始化的全局静态变量会被程序自动初始化为0(自动对象的值是任意的,除非他被显示初始化)
4 F# a) h1 d. L" A. n5 b 3)作用域:全局静态变量在声明他的文件之外是不可见的。准确地讲从定义之处开始到文件结尾。8 u/ J5 B4 i. Y t- ?' L+ \
当static用来修饰全局变量的时候,它就改变了全局变量的作用域(在声明他的文件之外是不可见的),但是没有改变它的存放位置,还是在静态存储区中。) ~7 P1 r/ k4 `' `1 F
: h) i- f% h+ v: R7 X
作用三:在模块内,一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是,这个函数被限制在声明它的模块的本地范围内使用。
3 k3 v, ] U* S
3 P1 u! B* G/ c* F& N* N这样定义的函数也成为静态函数:在函数的返回类型前加上关键字static,函数就被定义成为静态函数。函数的定义和声明默认情况下是extern的,但静态函数只是在声明他的文件当中可见,不能被其他文件所用。
& a: Y3 g! `/ i% ^定义静态函数的好处:
2 ]3 G5 B+ w) m+ w<1> 其他文件中可以定义相同名字的函数,不会发生冲突
0 Q) ~7 m- g' ?: x<2> 静态函数不能被其他文件所用。它定义一个本地的函数。& y+ n9 ~4 a4 E; s9 o. `7 Z$ s
这里我一直强调数据和函数的本地化,这对于程序的结构甚至优化都有巨大的好处,更大的作用是,本地化的数据和函数能给人传递很多有用的信息,能约束数据和函数的作用范围。在C++的对象和类中非常注重的私有和公共数据/函数其实就是本地和全局数据/函数的扩展,这也从侧面反应了本地化数据/函数的优势。( S. {% z6 d3 X# j- L
3 D8 H7 E. c. c% _+ Q- @
最后说一下存储说明符,在标准C语言中,存储说明符有以下几类:
, E; }% G5 T u1 M+ [auto、register、extern和static3 N ]) i2 u; e o
对应两种存储期:自动存储期和静态存储期。6 x5 v4 v* ?) C, d7 O0 h
auto和register对应自动存储期。具有自动存储期的变量在进入声明该变量的程序块时被建立,它在该程序块活动时存在,退出该程序块时撤销。
" x. o( K& T1 i* {2 I. i$ _; r7 @5 T关键字extern和static用来说明具有静态存储期的变量和函数。用static声明的局部变量具有静态存储持续期(static storage duration),或静态范围(static extent)。虽然他的值在函数调用之间保持有效,但是其名字的可视性仍限制在其局部域内。静态局部对象在程序执行到该对象的声明处时被首次初始化。
' K5 U( t! m" k7 \! ^9 L; N6 w2. const 关键字
2 v0 m/ I1 Z* G% c& qconst关键字也是一个优秀程序中经常用到的关键字。关键字const 的作用是为给读你代码的人传达非常有用的信息,实际上,声明一个参数为常量是为了告诉了用户这个参数的应用目的。通过给优化器一些附加的信息,使用关键字const也许能产生更紧凑的代码。合理地使用关键字const 可以使编译器很自然地保护那些不希望被改变的参数,防止其被无意的代码修改。简而言之,这样可以减少bug的出现。6 O1 n: k. z" Z3 M+ g: b; l
深入理解const关键字,你必须知道:
% {# Y2 f R% @2 t4 d% M& q" ua. const关键字修饰的变量可以认为有只读属性,但它绝不与常量划等号。如下代码:& y/ Z& W0 @; _6 J# L3 x$ P
const int i=5;$ }9 i [ K& Y3 \% m
int j=0;
! z3 [1 h! R5 f- V, T% `# X3 p ...4 P2 E/ V; ?" p. ]# \. x
i=j; //非法,导致编译错误,因为只能被读
; m5 Z: |7 _5 x0 n9 E7 }9 F j=i; //合法
- N' h: o8 h- Rb. const关键字修饰的变量在声明时必须进行初始化。如下代码:1 `6 z: A9 B) s" ?
const int i=5; //合法3 h$ l4 r; I7 M$ ]# s2 o! _
const int j; //非法,导致编译错误+ h/ x1 z/ J1 ?2 n* N9 N
c. 用const声明的变量虽然增加了分配空间,但是可以保证类型安全。const最初是从C++变化得来的,它可以替代define来定义常量。在旧版本(标准前)的c中,如果想建立一个常量,必须使用预处理器:, @" A9 X ?' m! D. P- z" c- \
#define PI 3.14159
A) h+ S- D9 h- b# x! r) z7 L此后无论在何处使用PI,都会被预处理器以3.14159替代。编译器不对PI进行类型检查,也就是说可以不受限制的建立宏并用它来替代值,如果使用不慎,很可能由预处理引入错误,这些错误往往很难发现。而且,我们也不能得到PI的地址(即不能向PI传递指针和引用)。const的出现,比较好的解决了上述问题。* C. [& c n# o2 b# q# p+ M ?9 M
d. C标准中,const定义的常量是全局的。! O% G, x: f- ^! `3 W8 y3 J
e. 必须明白下面语句的含义,我自己是反复记忆了许久才记住,方法是:若是想定义一个只读属性的指针,那么关键字const要放到‘* ’后面。4 `# a: P+ L! O
char *const cp; //指针不可改变,但指向的内容可以改变! I" d& E7 B* y: W* u' S
char const *pc1; //指针可以改变,但指向的内容不能改变: p. @% K* z( B- I2 Z9 l- q: y. G4 j
const char *pc2; //同上(后两个声明是等同的)+ }* t" j8 |$ u5 q. O
f. 将函数传入参数声明为const,以指明使用这种参数仅仅是为了效率的原因,而不是想让调用函数能够修改对象的值。6 [; B4 y \7 ]/ _% w7 n+ t
参数const通常用于参数为指针或引用的情况,且只能修饰输入参数;若输入参数采用“值传递”方式,由于函数将自动产生临时变量用于复制该参数,该参数本就不需要保护,所以不用const修饰。例子:
' O8 T( f# l0 ~) Y; dvoid fun0(const int * a );
3 x4 P1 Q3 f: F8 evoid fun1(const int & a);
% d1 t) ?+ j' h8 r* Z0 p# T$ w调用函数的时候,用相应的变量初始化const常量,则在函数体中,按照const所修饰的部分进行常量化,如形参为const int * a,则不能对传递进来的指针所指向的内容进行改变,保护了原指针所指向的内容;如形参为const int & a,则不能对传递进来的引用对象进行改变,保护了原对象的属性。$ \+ A4 r8 h& C3 i' j
g. 修饰函数返回值,可以阻止用户修改返回值。(在嵌入式C中一般不用,主要用于C++)
$ P. C" H1 m. F$ [) L2 G( J @+ ^ h. const消除了预处理器的值替代的不良影响,并且提供了良好的类型检查形式和安全性,在可能的地方尽可能的使用const对我们的编程有很大的帮助,前提是:你对const有了足够的理解。
; X0 @2 |8 a1 A 最后,举两个常用的标准C库函数声明,它们都是使用const的典范。
. p6 n/ Q k* }- J4 ?: ^( [ 1.字符串拷贝函数:char *strcpy(char *strDest,const char *strSrc);# A& }' A4 \% J4 j( Y% P3 }6 k
2.返回字符串长度函数:int strlen(const char *str);0 J0 B1 k+ ~$ p2 e4 h& H4 s
6 L$ S( f; z6 |0 s, L( \
3. volatile关键字
2 p; k& P& ]2 s* t5 `一个定义为volatile 的变量是说这变量可能会被意想不到地改变,这样,编译器就不会去假设这个变量的值了。精确地说就是,优化器在用到这个变量时必须每次都小心地重新读取这个变量的值,而不是使用保存在寄存器里的备份。
9 _6 e! c) j7 O/ C8 ]: h3 M由于访问寄存器的速度要快过RAM,所以编译器一般都会作减少存取外部RAM的优化。比如: $ f; f! y3 k n4 O' i3 r
static int i=0;
: h I; c/ S% S3 \9 D4 c* w& r p+ o/ y; H: m0 j+ T
* ]7 H2 T- C: w5 _$ ]int main(void) * S! e5 F/ n3 F N' V
{ 4 i4 x2 p2 Y* `: x
...
1 W$ T6 q2 |/ B3 w4 L) e while (1)
) ?' I+ @9 |* i# p {
! E) F% [/ ?9 L. f- D, H& O& B2 ~3 p if (i)
5 ]) N0 L& {4 Y% s( l) P dosomething();
! V2 M. D- I/ Z% W" P% l }
$ ?; }+ z! G& u} 1 u' L* z1 \) T' k0 z, ]3 X
8 Z4 [9 t$ x- D# n4 _
/ X! I1 M3 z4 {3 A& _- @* T5 S/* Interrupt service routine. */
) n* n* z, }2 ~! G) k) r9 O2 }void ISR_2(void)
$ n2 X8 J# v+ b# u: ~{
! X& N% `3 X* f0 k3 v i=1; : Y2 M* p' X+ D, u; r7 }0 ~
} 2 B' Y4 N" r; i6 K& n$ Q
( Z& y- X y( @
+ c0 h+ X6 d* P* R3 R" k+ | 程序的本意是希望ISR_2中断产生时,在main当中调用dosomething函数,但是,由于编译器判断在main函数里面没有修改过i,因此可能只执行一次对从i到某寄存器的读操作,然后每次if判断都只使用这个寄存器里面的“i副本”,导致dosomething永远也不会被调用。
0 f9 P% r; q* C% f' |' W
0 V2 N: _& t' e# p/ o
0 D ~: I1 ?7 O) p/ R4 l8 S如果将将变量加上volatile修饰,则编译器保证对此变量的读写操作都不会被优化(肯定执行)。此例中i也应该如此说明。 7 ?: A! a' i. X0 `
* v7 ~5 b' v( f8 Q
. v: a/ O# P/ f9 ~# a一般说来,volatile用在如下的几个地方:
4 V5 X @1 ~1 j, ]" h
* F3 a8 S; P! F* k; R
% e0 ^, Z4 u- Q2 N, Q& K1、中断服务程序中修改的供其它程序检测的变量需要加volatile;
% E6 } c$ Z9 f
$ [3 Q) n) T' r' {. B3 d, ~3 K7 L) W2 n
2、多任务环境下各任务间共享的标志应该加volatile;
5 _0 }# d0 g7 a
' Z+ t6 X4 I: f' D: x3 y( {& V( e! O
3、存储器映射的硬件寄存器通常也要加volatile说明,因为每次对它的读写都可能有不同意义;6 `" T( n& ]8 _5 P* Z6 k
不懂得volatile 的内容将会带来灾难,这也是区分C语言和嵌入式C语言程序员的一个关键因素。为强调volatile的重要性,再次举例分析:- K6 ~. D6 o/ F. T3 [6 Z! X
代码一:
0 S( I& d9 Z0 p8 y* Q: z: Tint a,b,c; " u6 {- X3 m8 F
//读取I/O空间0x100端口的内容
$ X" S, Q6 K( I* O/ h9 }3 Wa= inword(0x100); . r v% x) u- C
b=a; 7 L& {3 G5 I' ~ b
a=inword(0x100) ) J; t& ^- s) [4 ]4 K
c=a;
$ B4 l; ~+ u$ s& m$ [+ D代码二: / {- b" F3 D" t/ h) e V5 i" u
volatile int a; 0 ~4 B7 u8 Z9 T
int a,b,c; ( V8 {1 `/ e4 o3 u
//读取I/O空间0x100端口的内容 / G: x8 V9 ?! j4 c* |
a= inword(0x100);
" G" V1 [% K& B! w7 y7 eb=a; ' L/ ?! }, W( P6 g9 i
a=inword(0x100) & B- S- ?7 K: U8 ^& O) P
c=a;
7 W% m% c- x ?在上述例子中,代码一会被绝大多数编译器优化为如下代码:
, U5 n- P" {7 F4 m `: ?- ~ a=inword(0x100)% X3 Q8 V. U, w# w3 d/ X
b=a;: q4 I# A2 m; [, @! C
c=a;
( t Y( H3 P/ l4 w1 A& U3 ^这显然与编写者的目的不相符,会出现I/O空间0x100端口漏读现象,若是增加volatile,像代码二所示的那样,优化器将不会优化掉任何代码.
; b, C: R" T7 \. D, W; F 从上面来看,volatile关键字是会降低编译器优化力度的,但它保证了程序的正确性,所以在适合的地方使用关键字volatile是件考验编程功底的事情.
5 T- l% G: n" _( T1 w3 V& ?
+ v8 |; p2 c0 X/ m& `" c! J4.struct与typedef关键字( \+ N# Y* h& T; B$ s: i
面对一个人的大型C/C++程序时,只看其对struct的使用情况我们就可以对其编写者的编程经验进行评估。因为一个大型的C/C++程序,势必要涉及一些(甚至大量)进行数据组合的结构体,这些结构体可以将原本意义属于一个整体的数据组合在一起。从某种程度上来说,会不会用struct,怎样用struct是区别一个开发人员是否具备丰富开发经历的标志。
# a: i1 V4 j5 {& I0 p 在网络协议、通信控制、嵌入式系统的C/C++编程中,我们经常要传送的不是简单的字节流(char型数组),而是多种数据组合起来的一个整体,其表现形式是一个结构体。, v% M! M5 N9 E) C h8 P. @
经验不足的开发人员往往将所有需要传送的内容依顺序保存在char型数组中,通过指针偏移的方法传送网络报文等信息。这样做编程复杂,易出错,而且一旦控制方式及通信协议有所变化,程序就要进行非常细致的修改。; l7 U0 l$ i4 s, y( H- T
用法:
0 X& G, m, c3 p; {+ Q; v4 @在C中定义一个结构体类型要用typedef:) W6 Y: i( K* C9 W
typedef struct Student
; N4 t7 n# W6 a; |/ ?{
& l3 l7 r; `" F7 C8 q# p int a;1 m1 ?3 w/ Q r
}Stu;
) |" H1 M) y8 B. G于是在声明变量的时候就可:Stu stu1;
- @3 |3 t0 h$ S/ [+ f ?如果没有typedef就必须用struct Student stu1;来声明% R- s5 B/ Z* }2 s( q
这里的Stu实际上就是struct Student的别名。
+ J; Y* v% y9 ~ r7 c另外这里也可以不写Student(于是也不能struct Student stu1;了)# f8 R6 z/ F: t' |5 s% y7 \
typedef struct
8 F$ P5 `) W( w{. r# [ K {' N; T. X0 P# @
int a;
$ G4 z0 {8 {* O7 |( D}Stu;
5 o' x% S7 U2 T! y( F: t# s# nstruct关键字的一个总要作用是它可以实现对数据的封装,有一点点类似与C++的对象,可以将一些分散的特性对象化,这在编写某些复杂程序时提供很大的方便性.* v4 {3 ^9 x4 s0 X: R( R8 E# B4 O
比如编写一个菜单程序,你要知道本级菜单的菜单索引号、焦点在屏上是第几项、显示第一项对应的菜单条目索引、菜单文本内容、子菜单索引、当前菜单执行的功能操作。若是对上述条目单独操作,那么程序的复杂程度将会大到不可想象,若是菜单层数少些还容易实现,一旦菜单层数超出四层,呃~我就没法形容了。若是有编写过菜单程序的朋友或许理解很深。这时候结构体struct就开始显现它的威力了:7 p" G( P' I# R
//结构体定义" `# f" J" \( C$ w0 Y
typedef struct+ B: O0 \9 V" I+ z J" a
{ t3 B* j% t; `0 T0 |
unsigned char CurrentPanel;//本级菜单的菜单索引号
0 b- `! v, _% x8 H, I+ W8 b3 sunsigned char ItemStartDisplay; //显示第一项对应的菜单条目索引
% N1 R" W4 G) U/ Z3 ^0 x$ Munsigned char FocusLine; //焦点在屏上是第几项
# F0 F* _1 Q6 u) \: s}Menu_Statestruct;
2 c+ D8 l% g: F4 r 3 Y; p" B6 I/ \4 [
typedef struct
- M: z& e& Q: l7 g! T8 O* b{
6 Q, {: }6 q8 Iunsigned char *MenuTxt; //菜单文本内容
( W0 W; w' g) ]! Z& H- cunsigned char MenuChildID;//子菜单索引
# W+ j7 }" H% E# ~. Pvoid (*CurrentOperate)();//当前菜单执行的功能操作: p: G4 ]; \- @1 L
}MenuItemStruct;
5 j, I& S5 u" } . ?7 Q' d7 W* n0 t5 K/ E. S: N
typedef struct
" A# s4 b! J! e6 W' g{/ T$ }: y+ E: @/ [
MenuItemStruct *MenuPanelItem;
! s9 t/ t' Q, a6 wunsigned char MenuItEMCount;0 E* f7 z0 L, y
}MenuPanelStruct;
L! i8 V3 F1 k: E" N7 d( h2 e
5 p& b/ {6 B C9 Q* c/ I' f |
|