由于访问寄存器的速度要快过RAM，所以编译器一般都会作减少存取外部RAM的优化。比如： 
static int i=0; 
int main(void) 
{ 
     ... 
     while (1) 
     { 
         if (i) 
             dosomething(); 
     } 
} 
/* Interrupt service routine. */ 
void ISR_2(void) 
{ 
      i=1; 
} 
程序的本意是希望ISR_2中断产生时，在main当中调用dosomething函数，但是，由于编译器判断在main函数里面没有修改过i，因此可能只执行一次对从i到某寄存器的读操作，然后每次if判断都只使用这个寄存器里面的“i副本”，导致dosomething永远也不会被调用。

如果将将变量加上volatile修饰，则编译器保证对此变量的读写操作都不会被优化（肯定执行）。此例中i也应该如此说明。 
一般说来，volatile用在如下的几个地方： 
1、中断服务程序中修改的供其它程序检测的变量需要加volatile； 
2、多任务环境下各任务间共享的标志应该加volatile； 
3、存储器映射的硬件寄存器通常也要加volatile说明，因为每次对它的读写都可能有不同意义； 
另外，以上这几种情况经常还要同时考虑数据的完整性（相互关联的几个标志读了一半被打断了重写），在1中可以通过关中断来实现，2中可以禁止任务调度，3中则只能依靠硬件的良好设计了。 
1. 因为volatile抑制了优化，因而应尽量减少对它的引用操作，最好只对它进行简单的读写赋值，如： 
volatile char *pcWr_g; 
... 
while (...) 
     *pcWr_g++=UDR; 
... 

考虑改写成： 

char *pcTemp; 
... 
pcTemp=pcWr_g; 
while (...) 
     *pcTemp++=UDR; 
pcWr_g=pcTemp; 
... 
（其实即便pcWr_g是普通的全局变量，一般而言也是改写后的效率高些，可以在循环中只针对寄存器操作） 
2. 优化还会清除死代码、执行代码合并等，因而某些C语句可能找不到直接对应的汇编代码，这应该只会给调试设置断点有影响，不影响运行结果。 
3. 类似 
for (i=0; i<10000; i++) 
     j=0; 
之类的延时，如果不把j或者i说明成volatile，编译器都会当成无用代码把优化掉 

文章二： 
volatile的本意是一般有两种说法--1.“暂态的”；2.“易变的”。 
这两种说法都有可行。但是究竟volatile是什么意思，现举例说明（以Keil-c与a51为例 例子来自Keil FQA）,看完例子后你应该明白volatile的意思了，如果还不明白，那只好 再看一遍了。 

例1. 

void main (void) 
{ 
volatile int i; 
int j; 

i = 1;   //1   不被优化 i=1 
i = 2;   //2   不被优化 i=1 
i = 3;   //3   不被优化 i=1 

j = 1;   //4   被优化 
j = 2;   //5   被优化 
j = 3;   //6   j = 3 
} 
--------------------------------------------------------------------- 
例2. 

函数： 

void func (void) 
{ 
unsigned char xdata xdata_junk; 
unsigned char xdata *p = &xdata_junk; 
unsigned char t1, t2; 

t1 = *p; 
t2 = *p; 
} 

编译的汇编为： 

0000 7E00     R      MOV      R6,#HIGH xdata_junk 
0002 7F00     R      MOV      R7,#LOW xdata_junk 
;---- Variable ’p’ assigned to Register ’R6/R7’ ---- 

0004 8F82           MOV      DPL,R7 
0006 8E83           MOV      DPH,R6 

;!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 注意 
0008 E0             MOVX     A,@DPTR 
0009 F500     R      MOV      t1,A 

000B F500     R      MOV      t2,A 
;!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 
000D 22             RET       

将函数变为： 
void func (void) 
{ 
volatile unsigned char xdata xdata_junk; 
volatile unsigned char xdata *p = &xdata_junk; 
unsigned char t1, t2; 

t1 = *p; 
t2 = *p; 
} 

编译的汇编为： 
0000 7E00     R      MOV      R6,#HIGH xdata_junk 
0002 7F00     R      MOV      R7,#LOW xdata_junk 
;---- Variable ’p’ assigned to Register ’R6/R7’ ---- 

0004 8F82           MOV      DPL,R7 
0006 8E83           MOV      DPH,R6 

;!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 
0008 E0             MOVX     A,@DPTR 
0009 F500     R      MOV      t1,A         ;a处 

000B E0             MOVX     A,@DPTR 
000C F500     R      MOV      t2,A 
;!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 

000E 22             RET       


比较结果可以看出来，未用volatile关键字时，只从*p所指的地址读一次 
如在a处*p的内容有变化，则t2得到的则不是真正*p的内容。 

--------------------------------------------------------------------- 
例3 


volatile unsigned char bdata var;   // use volatile keyword here 
sbit var_0 = var^0; 
sbit var_1 = var^1; 
unsigned char xdata values[10]; 

void main (void)   { 
   unsigned char i; 

   for (i = 0; i < sizeof (values); i++)   { 
     var = values; 
     if (var_0)   { 
       var_1 = 1; //a处 
         
       values = var;   // without the volatile keyword, the compiler 
                         // assumes that ’var’ is unmodified and does not 
                         // reload the variable content. 
     } 
   } 
} 


在此例中，如在a处到下一句运行前，var如有变化则不会，如var=0xff; 则在 
values = var;得到的还是values = 1; 

--------------------------------------------------------------------- 
应用举例： 

例1. 
#define DBYTE ((unsigned char volatile data   *) 0) 

说明：此处不用volatile关键字，可能得不到真正的内容。 
--------------------------------------------------------------------- 

例2. 


#define TEST_VOLATILE_C   

//*************************************************************** 
// verwendete Include Dateien 
//*************************************************************** 
#if __C51__ < 600 
   #error: !! Keil 版本不正确 
#endif 

//*************************************************************** 
// 函数 void v_IntOccured(void) 
//*************************************************************** 
extern void v_IntOccured(void); 

//*************************************************************** 
// 变量定义 
//*************************************************************** 
char xdata cValue1;           //全局xdata 
char volatile xdata cValue2; //全局xdata 

//*************************************************************** 
// 函数： v_ExtInt0() 
// 版本： 
// 参数： 
// 用途：cValue1++,cValue2++ 
//*************************************************************** 
void v_ExtInt0(void) interrupt 0 { 
   cValue1++; 
   cValue2++;   
}   

//*************************************************************** 
// 函数： main() 
// 版本： 
// 参数： 
// 用途：测试volatile 
//*************************************************************** 

void main() { 
char cErg; 

//1. 使cErg=cValue1; 
cErg = cValue1; 

//2. 在此处仿真时手动产生中断INT0,使cValue1++; cValue2++ 
if (cValue1 != cErg) 
   v_IntOccured(); 

//3. 使cErg=cValue2; 
cErg = cValue2; 

//4. 在此处仿真时手动产生中断INT0,使cValue1++; cValue2++ 
if (cValue2 != cErg) 
   v_IntOccured(); 
   
//5. 完成 
   while (1); 
} 

//*************************************************************** 
// 函数： v_IntOccured() 
// 版本： 
// 参数： 
// 用途： 死循环 
//*************************************************************** 
void v_IntOccured() { 
   while(1); 
} 

仿真可以看出，在没有用volatile时，即2处，程序不能进入v_IntOccured(); 
但在4处可以进入v_IntOccured(); 

*********************************************************************************************** 


关于volatile关键字的说明以及测试 
volatile关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素更改，比如 操作系统、硬件或者其它线程等。遇到这个关键字声明的变量，编译器对访问该变量的代码就不再进行优化，从而可以提供对特殊地址的稳定访问。 
使用该关键字的例子如下： 
int volatile nVint; 
当要求使用volatile 声明的变量的值的时候，系统总是重新从它所在的内存读取数据，即使它前面的指令刚刚从该处读取过数据。而且读取的数据立刻被保存。 
例如： 
volatile int i=10; 
int a = i; 
。。。//其他代码，并未明确告诉编译器，对i进行过操作 
int b = i; 
volatile 指出 i是随时可能发生变化的，每次使用它的时候必须从i的地址中读取，因而编译器生成的汇编代码会重新从i的地址读取数据放在b中。而优化做法是，由于编译器发现两次从i读数据的代码之间的代码没有对i进行过操作，它会自动把上次读的数据放在b中。而不是重新从i里面读。这样以来，如果i是一个寄存器变量或者表示一个端口数据就容易出错，所以说volatile可以保证对特殊地址的稳定访问 。 
注意，在vc6中，一般调试模式没有进行代码优化，所以这个关键字的作用看不出来。下面通过插入汇编代码，测试有无volatile关键字，对程序最终代码的影响： 
首先用classwizard建一个win32 console工程，插入一个voltest.cpp文件，输入下面的代码： 
＃i nclude 
void main() 
{ 
int i=10; 
int a = i; 
printf("i= %d\n",a); 
         //下面汇编语句的作用就是改变内存中i的值，但是又不让编译器知道 
__asm { 
   mov          dword ptr [ebp-4], 20h 
} 
int b = i; 
printf("i= %d\n",b); 
} 
然后，在调试版本模式运行程序，输出结果如下： 
i = 10 
i = 32 
然后，在release版本模式运行程序，输出结果如下： 
i = 10 
i = 10 
输出的结果明显表明，release模式下，编译器对代码进行了优化，第二次没有输出正确的i值。 
下面，我们把 i的声明加上volatile关键字，看看有什么变化： 

＃i nclude 
void main() 
{ 
volatile int i=10; 
int a = i; 
printf("i= %d\n",a); 
__asm { 
   mov          dword ptr [ebp-4], 20h 
} 
int b = i; 
printf("i= %d\n",b); 
} 
分别在调试版本和release版本运行程序，输出都是： 
i = 10 
i = 32 
这说明这个关键字发挥了它的作用！ 

************************************************************************************ 

发贴心情 
上午在CSDN的C＋＋版逛时，发现有人在问volatile关键字的用义和用法。于是乎便写了这篇BLOG。 
如果你懂一点点的编译器的知识我想你都会知道编译器在编译你的代码的时候，用进行自动优化的，用以产生优化指令。同上操作系统和一些线程同样也会对你所定义的一些变量做出一些你所不知道的更改。这样的更改我们称为，隐式修改，因为你不知道，编译器在什么情况下，在那里做出了优化，甚至你都不知道，或是不能肯定编译器到底有没有对你的代码做出优化。 
直接点把你看看下面的例子 
＃i nclude 
void main() 
{ 
int i=10; 
int a = i; 
printf("i= %d\n",a); 
__asm { 
mov dword ptr [ebp-4], 50h 
} 
//下面汇编语句的作用就是改变内存中i的值，但是又不让编译器知道,来隐式的修改了变量。 
int b = i; 
printf("i= %d\n",b); 
} 

然后，在调试版本(debug)模式运行程序，输出结果如下： 
i = 10 
i = 80 
然后，在release版本模式运行程序，输出结果如下： 
i = 10 
i = 10 

呵呵结果看到了吗？输出的结果明显表明，release模式下，编译器对代码进行了优化，第二次没有输出正确的i值。所以得出一个结论在VC中release模式编译代码时编译器会自动对你的代码来做起优化的。而调试版本(debug)模式下便不会。 

废话说了好多啊呵呵　下面继续说说 volatile 
下面，我们把 i的声明加上volatile关键字，看看有什么效果： 
＃i nclude 
void main() 
{ 
volatile int i=10; 
int a = i; 
printf("i= %d\n",a); 
__asm { 
   mov          dword ptr [ebp-4], 50h 
} 
int b = i; 
printf("i= %d\n",b); 
} 
这下你再在调试版本和release版本运行程序，看看输出结果是不是都是： 
i = 10 
i = 32 
估计大家看到这里便会明白了，volatile　这个关键字最最主要的意思是做什么的了。 

在MSDN中volatile是一个限定符，也称为keyword或描述符，"volatile 关键字指示字段可由操作系统、硬件或并发执行的线程在程序中进行修改。" 
当要求使用volatile 声明的变量的值的时候，系统总是重新从它所在的内存读取数据，即使它前面的指令刚刚从该处读取过数据。而且读取的数据立刻被保存。 

一般说来，volatile用在如下的几个地方： 
1、中断服务程序中修改的供其它程序检测的变量需要加volatile； 
2、多任务环境下各任务间共享的标志应该加volatile； 
3、存储器映射的硬件寄存器通常也要加volatile说明，因为每次对它的读写都可能由不同意义；   

声明方式为　　volatile declaration 

备注 
系统总是在 volatile 对象被请求的那一刻读取其当前值，即使上一条指令从同一对象请求值。而且，该对象的值在赋值时立即写入。 
volatile 修饰符通常用于由多个线程访问而不使用 lock 语句来序列化访问的字段。使用 volatile 修饰符能够确保一个线程检索由另一线程写入的最新值。 

备注部分由MSDN原文所说。 
本文参考：关于volatile关键字的说明以及测试（作者：iwaswzq）　有关volatile (函数前加volatile) 和inline的用法（作者：kobefly） 
15:47 2005-11-14　　50米于公司   下午无聊时所写。 

**************************************************************************************** 

关键字Const与Volatile的使用 
关键字const有什么含意？ 
我只要一听到被面试者说：“const意味着常数”，我就知道我正在和一个业余者打交道。去年Dan Saks已经在他的文章里完全概括了const的所有用法，因此ESP(译者：Embedded Systems Programming)的每一位读者应该非常熟悉const能做什么和不能做什么.如果你从没有读到那篇文章，只要能说出const意味着“只读”就可以了。尽管这个答案不是完全的答案，但我接受它作为一个正确的答案。（如果你想知道更详细的答案，仔细读一下Saks的文章吧。） 
如果应试者能正确回答这个问题，我将问他一个附加的问题： 
下面的声明都是什么意思？ 

const int a; 
int const a; 
const int *a; 
int * const a; 
int const * a const; 

/******/ 
前两个的作用是一样，a是一个常整型数。第三个意味着a是一个指向常整型数的指针（也就是，整型数是不可修改的，但指针可以）。第四个意思a是一个指向整型数的常指针（也就是说，指针指向的整型数是可以修改的，但指针是不可修改的）。最后一个意味着a是一个指向常整型数的常指针（也就是说，指针指向的整型数是不可修改的，同时指针也是不可修改的）。如果应试者能正确回答这些问题，那么他就给我留下了一个好印象。顺带提一句，也许你可能会问，即使不用关键字 const，也还是能很容易写出功能正确的程序，那么我为什么还要如此看重关键字const呢？我也如下的几下理由： 
关键字const的作用是为给读你代码的人传达非常有用的信息，实际上，声明一个参数为常量是为了告诉了用户这个参数的应用目的。如果你曾花很多时间清理其它人留下的垃圾，你就会很快学会感谢这点多余的信息。（当然，懂得用const的程序员很少会留下的垃圾让别人来清理的。） 
通过给优化器一些附加的信息，使用关键字const也许能产生更紧凑的代码。 
合理地使用关键字const可以使编译器很自然地保护那些不希望被改变的参数，防止其被无意的代码修改。简而言之，这样可以减少bug的出现。 


Volatile 

8. 关键字volatile有什么含意?并给出三个不同的例子。 
一个定义为volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。精确地说就是，优化器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。下面是volatile变量的几个例子： 
•; 并行设备的硬件寄存器（如：状态寄存器） 
•; 一个中断服务子程序中会访问到的非自动变量(Non-automatic variables) 
•; 多线程应用中被几个任务共享的变量 

回答不出这个问题的人是不会被雇佣的。我认为这是区分C程序员和嵌入式系统程序员的最基本的问题。搞嵌入式的家伙们经常同硬件、中断、RTOS等等打交道，所有这些都要求用到volatile变量。不懂得volatile的内容将会带来灾难。 
假设被面试者正确地回答了这是问题（嗯，怀疑是否会是这样），我将稍微深究一下，看一下这家伙是不是直正懂得volatile完全的重要性。 
•; 一个参数既可以是const还可以是volatile吗？解释为什么。 
•; 一个指针可以是volatile 吗？解释为什么。 
•; 下面的函数有什么错误： 
int square(volatile int *ptr) 
{ 
return *ptr * *ptr; 
} 

下面是答案： 
•; 是的。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。 
•; 是的。尽管这并不很常见。一个例子是当一个中服务子程序修该一个指向一个buffer的指针时。 
•; 这段代码有点变态。这段代码的目的是用来返指针*ptr指向值的平方，但是，由于*ptr指向一个volatile型参数，编译器将产生类似下面的代码： 


int square(volatile int *ptr) 
{ 
int a,b; 
a = *ptr; 
b = *ptr; 
return a * b; 
} 


由于*ptr的值可能被意想不到地该变，因此a和b可能是不同的。结果，这段代码可能返不是你所期望的平方值！正确的代码如下： 

long square(volatile int *ptr) 
{ 
int a; 
a = *ptr; 
return a * a; 
}

转载于http://blog.21ic.com/user1/6113/archives/2009/64856.html

bcmp（比较内存内容）  
相关函数  bcmp，strcasecmp，strcmp，strcoll，strncmp，strncasecmp
 
表头文件  #include<string.h>
 
定义函数  int bcmp ( const void *s1,const void * s2,int n);
 
函数说明  bcmp()用来比较s1和s2所指的内存区间前n个字节，若参数n为0，则返回0。
 
返回值  若参数s1 和s2 所指的内存内容都完全相同则返回0 值，否则返回非零值。
 
附加说明  建议使用memcmp()取代。
 
范例  参考memcmp()。
 
　

 
bcopy（拷贝内存内容）  
相关函数  memccpy，memcpy，memmove，strcpy，ctrncpy
 
表头文件  #include <string.h>
 
定义函数  void bcopy ( const void *src,void *dest ,int n);
 
函数说明  bcopy()与memcpy()一样都是用来拷贝src所指的内存内容前n个字节到dest所指的地址，不过参数src与dest在传给函数时是相反的位置。
 
返回值  
 
附加说明  建议使用memcpy()取代
 
范例  #include<string.h>
main()
{
char dest[30]=”string(a)”;
char src[30]=”string\0string”;
int i;
bcopy(src,dest,30);/* src指针放在前*/
printf(bcopy(): “)
for(i=0;i<30;i++)
printf(“%c”,dest[i]);
memcpy(dest src,30); /*dest指针放在钱*/
printf(‘\nmemcpy() : “);
for(i=0;i<30;i++)
printf(“%c”,dest[i]);
 
执行  bcopy() : string string
memcpy() :string sring
 
　

 
bzero（将一段内存内容全清为零）  
相关函数  memset，swab
 
表头文件  #include<string.h>
 
定义函数  void bzero(void *s,int n)；
 
函数说明  bzero()会将参数s所指的内存区域前n个字节，全部设为零值。相当于调用memset((void*)s,0,size_tn);
 
返回值  
 
附加说明  建议使用memset取代
 
范例  参考memset()。
 
　

 
index（查找字符串中第一个出现的指定字符）  
相关函数  rindex，srechr，strrchr
 
表头文件  #include<string.h>
 
定义函数  char * index( const char *s, int c);
 
函数说明  index()用来找出参数s字符串中第一个出现的参数c地址，然后将该字符出现的地址返回。字符串结束字符(NULL)也视为字符串一部分。
 
返回值  如果找到指定的字符则返回该字符所在地址，否则返回0。
 
范例  #include<string.h>
main()
{
char *s =”0123456789012345678901234567890”;
char *p;
p =index(s,’5’);
printf(%s\n”,p);
}
 
执行  5.68E+25
 
　

 
memccpy（拷贝内存内容）  
相关函数  bcopy，memcpy，memmove，strcpy，strncpy
 
表头文件  #include<string.h>
 
定义函数  void * memccpy(void *dest, const void * src, int c,size_t n);
 
函数说明  memccpy()用来拷贝src所指的内存内容前n个字节到dest所指的地址上。与memcpy()不同的是，memccpy()会在复制时检查参数c是否出现，若是则返回dest中值为c的下一个字节地址。
 
返回值  返回指向dest中值为c的下一个字节指针。返回值为0表示在src所指内存前n个字节中没有值为c的字节。
 
范例  #include<string.h>
main()
{
char a[]="string[a]";
char b[]="string(b)";
memccpy(a,b,'B',sizeof(b));
printf("memccpy():%s\n",a);
}
 
执行  memccpy():string(b)
 
　

 
memchr（在某一内存范围中查找一特定字符）  
相关函数  index，rindex，strchr，strpbrk，strrchr，strsep，strspn，strstr
 
表头文件  #include<string.h>
 
定义函数  void * memchr(const void *s,int c,size_t n);
 
函数说明  memchr()从头开始搜寻s所指的内存内容前n个字节，直到发现第一个值为c的字节，则返回指向该字节的指针。
 
返回值  如果找到指定的字节则返回该字节的指针，否则返回0。
 
范例  #include <string.h>
main()
{
char *s="0123456789012345678901234567890";
char *p;
p=memchr(s,'5',10);
printf("%s\n",p);
}
 
执行  5.68E+25
 
　

 
memcmp（比较内存内容）  
相关函数  bcmp，strcasecmp，strcmp，strcoll，strncmp，strncasecmp
 
表头文件  #include<string.h>
 
定义函数  int memcmp (const void *s1,const void *s2,size_t n);
 
函数说明  memcmp()用来比较s1和s2所指的内存区间前n个字符。字符串大小的比较是以ASCII码表上的顺序来决定，次顺序亦为字符的值。memcmp()首先将s1第一个字符值减去s2第一个字符的值，若差为0则再继续比较下个字符，若差值不为0则将差值返回。例如，字符串"Ac"和"ba"比较则会返回字符'A'(65)和'b'(98)的差值(－33)。
 
返回值  若参数s1和s2所指的内存内容都完全相同则返回0值。s1若大于s2则返回大于0的值。s1若小于s2则返回小于0的值。
 
范例  #include<string.h>
main()
{
char *a ="aBcDeF";
char *b="AbCdEf";
char *c="aacdef";
char *d="aBcDeF";
printf("memcmp(a,b):%d\n",memcmp((void*)a,(void*) b,6));
printf("memcmp(a,c):%d\n",memcmp((void*)a,(void*) c,6));
printf("memcmp(a,d):%d\n",memcmp((void*)a,(void*) d,6));
 
执行  memcmp(a,b):1 /*字符串a>字符串b，返回1*/
memcmp(a,c):-1 /* 字符串a<字符串c,返回－1*/
memcmp(a,d):0 /*字符串a＝字符串d，返回0*/
 
　

 
memcpy（拷贝内存内容）  
相关函数  bcopy，memccpy，memcpy，memmove，strcpy，strncpy
 
表头文件  #include<string.h>
 
定义函数  void * memcpy (void * dest ,const void *src, size_t n);
 
函数说明  memcpy()用来拷贝src所指的内存内容前n个字节到dest所指的内存地址上。与strcpy()不同的是，memcpy()会完整的复制n个字节，不会因为遇到字符串结束'\0'而结束。
 
返回值  返回指向dest的指针。
 
附加说明  指针src和dest所指的内存区域不可重叠。
 
范例  #include<string.h>
main()
{
char a[30]="string (a)";
char b[30]="string\0string";
int i;
strcpy(a,b);
printf("strcpy():");
for(i=0;i<30;i++)
printf("%c",a[i]);
memcpy(a,b,30);
printf("\nmemcpy() :");
for(i=0;i<30;i++)
printf("%c",a[i]);
}
 
执行  strcpy() : string a )
memcpy() : string string
 
　

 
memmove（拷贝内存内容）  
相关函数  bcopy，memccpy，memcpy，strcpy，strncpy
 
表头文件  #include<string.h>
 
定义函数  void * memmove(void *dest,const void *src,size_t n);
 
函数说明  memmove()与memcpy()一样都是用来拷贝src所指的内存内容前n个字节到dest所指的地址上。不同的是，当src和dest所指的内存区域重叠时，memmove()仍然可以正确的处理，不过执行效率上会比使用memcpy()略慢些。
 
返回值  返回指向dest的指针。
 
附加说明  指针src和dest所指的内存区域可以重叠。
 
范例  参考memcpy()。
 
　

 
memset（将一段内存空间填入某值）  
相关函数  bzero，swab
 
表头文件  #include<string.h>
 
定义函数  void * memset (void *s ,int c, size_t n);
 
函数说明  memset()会将参数s所指的内存区域前n个字节以参数c填入，然后返回指向s的指针。在编写程序时，若需要将某一数组作初始化，memset()会相当方便。
 
返回值  返回指向s的指针。
 
附加说明  参数c虽声明为int， 但必须是unsigned char ，所以范围在0到255之间。
 
范例  #include <string.h>
main()
{
char s[30];
memset (s,'A',sizeof(s));
s[30]='\0';
printf("%s\n",s);
}
 
执行  AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
 
　

 
rindex（查找字符串中最后一个出现的指定字符）  
相关函数  index，memchr，strchr，strrchr
 
表头文件  #include<string.h>
 
定义函数  char * rindex( const char *s,int c);
 
函数说明  rindex()用来找出参数s字符串中最后一个出现的参数c地址，然后将该字符出现的地址返回。字符串结束字符(NULL)也视为字符串一部分。
 
返回值  如果找到指定的字符则返回该字符所在的地址，否则返回0。
 
范例  #include <string.h>
mian()
{
char *s ="0123456789012345678901234567890";
char *p;
p=rindex(s,'5');
printf("%s\n",p);
}
 
执行  567890
 
　

 
strcasecmp（忽略大小写比较字符串）  
相关函数  bcmp，memcmp，strcmp，strcoll，strncmp
 
表头文件  #include<string.h>
 
定义函数  int strcasecmp (const char *s1, const char *s2);
 
函数说明  strcasecmp()用来比较参数s1和s2字符串，比较时会自动忽略大小写的差异。
 
返回值  若参数s1和s2字符串相同则返回0。s1长度大于s2长度则返回大于0 的值，s1 长度若小于s2 长度则返回小于0的值。
 
范例  #include <string.h>
main()
{
char *a="aBcDeF";
char *b="AbCdEf";
if(!strcasecmp(a,b))
printf("%s=%s\n",a,b);
}
 
执行  aBcDeF=AbCdEf
 
　

 
strcat（连接两字符串）  
相关函数  bcopy，memccpy，memcpy，strcpy，strncpy
 
表头文件  #include <string.h>
 
定义函数  char *strcat (char *dest,const char *src);
 
函数说明  strcat()会将参数src字符串拷贝到参数dest所指的字符串尾。第一个参数dest要有足够的空间来容纳要拷贝的字符串。
 
返回值  返回参数dest的字符串起始地址
 
范例  #include <string.h.>
main()
{
char a[30]="string(1)";
char b[]="string(2)";
printf("before strcat() : %s\n",a);
printf("after strcat() : %s\n",strcat(a,b));
}
 
执行  before strcat () : string(1)
after strcat () : string(1)string(2)
 
　

 
strchr（查找字符串中第一个出现的指定字符）  
相关函数  index，memchr，rinex，strbrk，strsep，strspn，strstr，strtok
 
表头文件  #include<string.h>
 
定义函数  char * strchr (const char *s,int c);
 
函数说明  strchr()用来找出参数s字符串中第一个出现的参数c地址，然后将该字符出现的地址返回。
 
返回值  如果找到指定的字符则返回该字符所在地址，否则返回0。
 
范例  #include<string.h>
main()
{
char *s=0123456789012345678901234567890”;
char *p;
p=strchr(s,'5');
printf("%s\n",p);
}
 
执行  5.68E+25
 
　

 
strcmp（比较字符串）  
相关函数  bcmp，memcmp，strcasecmp，strncasecmp，strcoll
 
表头文件  #include<string.h>
 
定义函数  int strcmp(const char *s1,const char *s2);
 
函数说明  strcmp()用来比较参数s1和s2字符串。字符串大小的比较是以ASCII 码表上的顺序来决定，此顺序亦为字符的值。strcmp()首先将s1第一个字符值减去s2第一个字符值，若差值为0则再继续比较下个字符，若差值不为0则将差值返回。例如字符串"Ac"和"ba"比较则会返回字符"A"(65)和'b'(98)的差值(－33)。
 
返回值  若参数s1和s2字符串相同则返回0。s1若大于s2则返回大于0的值。s1若小于s2则返回小于0 的值。
 
范例  #include<string.h>
main()
{
char *a="aBcDeF";
char *b="AbCdEf";
char *c="aacdef";
char *d="aBcDeF";
printf("strcmp(a,b) : %d\n",strcmp(a,b));
printf("strcmp(a,c) : %d\n",strcmp(a,c));
printf("strcmp(a,d) : %d\n",strcmp(a,d));
}
 
执行  strcmp(a,b) : 32
strcmp(a,c) :-31
strcmp(a,d) : 0
 
　

 
strcoll（采用目前区域的字符排列次序来比较字符串）  
相关函数  strcmp，bcmp，memcmp，strcasecmp，strncasecmp
 
表头文件  #include<string.h>
 
定义函数  int strcoll( const char *s1, const char *s2);
 
函数说明  strcoll()会依环境变量LC_COLLATE所指定的文字排列次序来比较s1和s2 字符串。
 
返回值  若参数s1和s2字符串相同则返回0。s1若大于s2则返回大于0的值。s1若小于s2则返回小于0 的值。
 
附加说明  若LC_COLLATE为"POSIX"或"C"，则strcoll()与strcmp()作用完全相同。
 
范例  参考strcmp()。
 
　

 
strcpy（拷贝字符串）  
相关函数  bcopy，memcpy，memccpy，memmove
 
表头文件  #include<string.h>
 
定义函数  char *strcpy(char *dest,const char *src);
 
函数说明  strcpy()会将参数src字符串拷贝至参数dest所指的地址。
 
返回值  返回参数dest的字符串起始地址。
 
附加说明  如果参数dest所指的内存空间不够大，可能会造成缓冲溢出(buffer Overflow)的错误情况，在编写程序时请特别留意，或者用strncpy()来取代。
 
范例  #include<string.h>
main()
{
char a[30]="string(1)";
char b[]="string(2)";
printf("before strcpy() :%s\n",a);
printf("after strcpy() :%s\n",strcpy(a,b));
}
 
执行  before strcpy() :string(1)
after strcpy() :string(2)
 
　

 
strcspn（返回字符串中连续不含指定字符串内容的字符数）  
相关函数  strspn
 
表头文件  #inclued<string.h>
 
定义函数  size_t strcspn ( const char *s,const char * reject);
 
函数说明  strcspn()从参数s字符串的开头计算连续的字符，而这些字符都完全不在参数reject 所指的字符串中。简单地说，若strcspn()返回的数值为n，则代表字符串s开头连续有n个字符都不含字符串reject内的字符。
 
返回值  返回字符串s开头连续不含字符串reject内的字符数目。
 
范例  #include <string.h>
main()
{
char *str="Linux was first developed for 386/486-based pcs.";
printf("%d\n",strcspn(str," "));
printf("%d\n",strcspn(str,"/-"));
printf("%d\n",strcspn(str,"1234567890"));
}
 
执行  5 /*只计算到“ ”的出现，所以返回“Linux”的长度*/
33 /*计算到出现“/”或“－”，所以返回到“6”的长度*/
30 /* 计算到出现数字字符为止，所以返回“3”出现前的长度*/
 
　

 
strdup（复制字符串）  
相关函数  calloc，malloc，realloc，free
 
表头文件  #include<string.h>
 
定义函数  char * strdup( const char *s);
 
函数说明  strdup()会先用maolloc()配置与参数s字符串相同的空间大小，然后将参数s字符串的内容复制到该内存地址，然后把该地址返回。该地址最后可以利用free()来释放。
 
返回值  返回一字符串指针，该指针指向复制后的新字符串地址。若返回NULL表示内存不足。
 
范例  #include<string.h>
main()
{
char a[]="strdup";
char *b;
b=strdup(a);
printf("b[ ]=\"%s\"\n",b);
}
 
执行  b[ ]="strdup"
 
　

 
strlen（返回字符串长度）  
相关函数  
 
表头文件  #include<string.h>
 
定义函数  size_t strlen (const char *s);
 
函数说明  strlen()用来计算指定的字符串s的长度，不包括结束字符"\0"。
 
返回值  返回字符串s的字符数。
 
范例  /*取得字符串str的长度*/
#include<string.h>
main()
{
char *str = "12345678";
printf("str length = %d\n", strlen(str));
}
 
执行  str length = 8
 
　

 
strncasecmp（忽略大小写比较字符串）  
相关函数  bcmp，memcmp，strcmp，strcoll，strncmp
 
表头文件  #include<string.h>
 
定义函数  int strncasecmp(const char *s1,const char *s2,size_t n);
 
函数说明  strncasecmp()用来比较参数s1和s2字符串前n个字符，比较时会自动忽略大小写的差异。
 
返回值  若参数s1和s2 字符串相同则返回0。s1 若大于s2则返回大于0的值，s1若小于s2则返回小于0 的值。
 
范例  #include<string.h>
main()
{
char *a="aBcDeF";
char *b="AbCdEf";
if(!strncasecmp(a,b))
printf("%s =%s\n",a,b);
}
 
执行  aBcDef=AbCdEf
 
　

 
strncat（连接两字符串）  
相关函数  bcopy，memccpy，memecpy，strcpy，strncpy
 
表头文件  #inclue <string.h>
 
定义函数  char * strncat(char *dest,const char *src,size_t n);
 
函数说明  strncat()会将参数src字符串拷贝n个字符到参数dest所指的字符串尾。第一个参数dest要有足够的空间来容纳要拷贝的字符串。
 
返回值  返回参数dest的字符串起始地址。
 
范例  #include <string.h>
main()
{
char a[30]="string(1)";
char b[]="string(2)";
printf("before strnact() :%s\n", a);
printf("after strncat() :%s\n", strncat(a,b,6));
}
 
执行  before strnact() : string(1)
after strncat() : string(1) string
 
　

 
strncpy（拷贝字符串）  
相关函数  bcopy，memccpy，memcpy，memmove
 
表头文件  #include<string.h>
 
定义函数  char * strncpy(char *dest,const char *src,size_t n);
 
函数说明  strncpy()会将参数src字符串拷贝前n个字符至参数dest所指的地址。
 
返回值  返回参数dest的字符串起始地址。
 
范例  #inclue <string.h>
main()
{
char a[30]="string(1)";
char b[]="string(2)";
printf("before strncpy() : %s\n",a);
printf("after strncpy() : %s\n",strncpy(a,b,6));
}
 
执行  before strncpy() : string(1)
after strncpy() : string(1)
 
　

 
strpbrk（查找字符串中第一个出现的指定字符）  
相关函数  index，memchr，rindex，strpbrk，strsep，strspn，strstr，strtok
 
表头文件  #include <include.h>
 
定义函数  char *strpbrk(const char *s,const char *accept);
 
函数说明  strpbrk()用来找出参数s 字符串中最先出现存在参数accept 字符串中的任意字符。
 
返回值  如果找到指定的字符则返回该字符所在地址，否则返回0。
 
范例  #include <string.h>
main()
{
char *s="0123456789012345678901234567890";
char *p;
p=strpbrk(s,"a1 839"); /*1会最先在s字符串中找到*/
printf("%s\n",p);
p=strprk(s,"4398");/*3 会最先在s 字符串中找到*/
printf("%s\n",p);
 
执行  1.23E+29
 
　

 
strrchr（查找字符串中最后出现的指定字符）  
相关函数  index，memchr，rindex，strpbrk，strsep，strspn，strstr，strtok
 
表头文件  #include<string.h>
 
定义函数  char * strrchr(const char *s, int c);
 
函数说明  strrchr()用来找出参数s字符串中最后一个出现的参数c地址，然后将该字符出现的地址返回。
 
返回值  如果找到指定的字符则返回该字符所在地址，否则返回0。
 
范例  #include<string.h>
main()
{
char *s="0123456789012345678901234567890";
char *p;
p=strrchr(s,'5');
printf("%s\n",p);
}
 
执行  567890
 
　

 
strspn（返回字符串中连续不含指定字符串内容的字符数）  
相关函数  strcspn，strchr，strpbrk，strsep，strstr
 
表头文件  #include<string.h>
 
定义函数  size_t strspn (const char *s,const char * accept);
 
函数说明  strspn()从参数s 字符串的开头计算连续的字符，而这些字符都完全是accept 所指字符串中的字符。简单的说，若strspn()返回的数值为n，则代表字符串s 开头连续有n 个字符都是属于字符串accept内的字符。
 
返回值  返回字符串s开头连续包含字符串accept内的字符数目。
 
范例  #include<string.h>
main()
{
char *str="Linux was first developed for 386/486-based PCs.";
char *t1="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
printf("%d\n",strspn(str,t1));
}
 
执行  5 /*计算大小写字母。不包含“ ”，所以返回Linux的长度。*/
 
　

 
strstr（在一字符串中查找指定的字符串）  
相关函数  index，memchr，rindex，strchr，strpbrk，strsep，strspn，strtok
 
表头文件  #include<string.h>
 
定义函数  char *strstr(const char *haystack,const char *needle);
 
函数说明  strstr()会从字符串haystack 中搜寻字符串needle，并将第一次出现的地址返回。
 
返回值  返回指定字符串第一次出现的地址，否则返回0。
 
范例  #include<string.h>
main()
{
char * s="012345678901234567890123456789";
char *p;
p= strstr(s,"901");
printf("%s\n",p);
}
 
执行  9.01E+21
 
　

 
strtok（分割字符串）  
相关函数  index，memchr，rindex，strpbrk，strsep，strspn，strstr
 
表头文件  #include<string.h>
 
定义函数  char * strtok(char *s,const char *delim);
 
函数说明  strtok()用来将字符串分割成一个个片段。参数s指向欲分割的字符串，参数delim则为分割字符串，当strtok()在参数s的字符串中发现到参数delim的分割字符时则会将该字符改为\0 字符。在第一次调用时，strtok()必需给予参数s字符串，往后的调用则将参数s设置成NULL。每次调用成功则返回下一个分割后的字符串指针。
 
返回值  返回下一个分割后的字符串指针，如果已无从分割则返回NULL。
 
范例  #include<string.h>
main()
{
char s[]="ab-cd : ef;gh :i-jkl;mnop;qrs-tu: vwx-y;z";
char *delim="-: ";
char *p;
printf("%s ";strtok(s,delim));
while((p=strtok(NULL,delim)))printf("%s ",p);
printf("\n");
}
 
执行  ab cd ef;gh i jkl;mnop;qrs tu vwx y;z /*－与:字符已经被\0 字符取代*/

    C程序一直由下列部分组成：

    1）正文段——CPU执行的机器指令部分；一个程序只有一个副本；只读，防止程序由于意外事故而修改自身指令；

    2）初始化数据段（数据段）——在程序中所有赋了初值的全局变量，存放在这里。

    3）非初始化数据段（bss段）——在程序中没有初始化的全局变量；内核将此段初始化为0.

    4）栈——增长方向：自顶向下增长；自动变量以及每次函数调用时所需要保存的信息（返回地址；环境信息）。

    5）堆——动态存储部分。

|-----------|
|                  |
|-----------|
|     栈          |
|-----------|
|     |             |
|    \|/            |
|                  |
|                  |
|    /|\            |
|     |             |
|-----------|
|     堆          |
|-----------|
| 未初始化   |
|-----------|
|    初始化   |    (.data)
|-----------|
|   正文段    |    (.text)
|-----------|

    二、 面向过程程序设计中的static

    1. 全局静态变量

    在全局变量之前加上关键字static，全局变量就被定义成为一个全局静态变量。

    1）内存中的位置：静态存储区（静态存储区在整个程序运行期间都存在）

    2）初始化：未经初始化的全局静态变量会被程序自动初始化为0（自动对象的值是任意的，除非他被显示初始化）

    3）作用域：全局静态变量在声明他的文件之外是不可见的。准确地讲从定义之处开始到文件结尾。

    看下面关于作用域的程序：

//teststatic1.c void display(); extern int n; int main() {    n = 20;    printf("%d\n",n);    display();    return 0; } //teststatic2.c static int n;    //定义全局静态变量，自动初始化为0，仅在本文件中可见 void display() {    n++;    printf("%d\n",n); }

    文件分别编译通过，但link的时候teststatic1.c中的变量n找不到定义，产生错误。

    定义全局静态变量的好处：

    <1>不会被其他文件所访问，修改

    <2>其他文件中可以使用相同名字的变量，不会发生冲突。

    2. 局部静态变量

    在局部变量之前加上关键字static，局部变量就被定义成为一个局部静态变量。

    1）内存中的位置：静态存储区

    2）初始化：未经初始化的全局静态变量会被程序自动初始化为0（自动对象的值是任意的，除非他被显示初始化）

    3）作用域：作用域仍为局部作用域，当定义它的函数或者语句块结束的时候，作用域随之结束。

    注：当static用来修饰局部变量的时候，它就改变了局部变量的存储位置，从原来的栈中存放改为静态存储区。但是局部静态变量在离开作用域之后，并没有被销毁，而是仍然驻留在内存当中，直到程序结束，只不过我们不能再对他进行访问。

    当static用来修饰全局变量的时候，它就改变了全局变量的作用域（在声明他的文件之外是不可见的），但是没有改变它的存放位置，还是在静态存储区中。

    3. 静态函数

    在函数的返回类型前加上关键字static，函数就被定义成为静态函数。

    函数的定义和声明默认情况下是extern的，但静态函数只是在声明他的文件当中可见，不能被其他文件所用。

    例如：

//teststatic1.c void display(); static void staticdis(); int main() {    display();    staticdis();    renturn 0; } //teststatic2.c void display() {    staticdis();    printf("display() has been called \n"); } static void staticdis() {    printf("staticDis() has been called\n"); }

    文件分别编译通过，但是连接的时候找不到函数staticdis（）的定义，产生错误。

    定义静态函数的好处：

    <1> 其他文件中可以定义相同名字的函数，不会发生冲突

    <2> 静态函数不能被其他文件所用。

    存储说明符auto，register，extern，static，对应两种存储期：自动存储期和静态存储期。

    auto和register对应自动存储期。具有自动存储期的变量在进入声明该变量的程序块时被建立，它在该程序块活动时存在，退出该程序块时撤销。

    关键字extern和static用来说明具有静态存储期的变量和函数。用static声明的局部变量具有静态存储持续期（static storage duration），或静态范围（static extent）。虽然他的值在函数调用之间保持有效，但是其名字的可视性仍限制在其局部域内。静态局部对象在程序执行到该对象的声明处时被首次初始化。

    由于static变量的以上特性，可实现一些特定功能。

    1. 统计次数功能

    声明函数的一个局部变量，并设为static类型，作为一个计数器，这样函数每次被调用的时候就可以进行计数。这是统计函数被调用次数的最好的办法，因为这个变量是和函数息息相关的，而函数可能在多个不同的地方被调用，所以从调用者的角度来统计比较困难。代码如下：

void count(); int main() { int i; for (i = 1; i <= 3; i++)    count();    return 0; } void count() { static num = 0; num++; printf(" I have been called %d",num,"times\n"); }

    输出结果为：

    I have been called 1 times.

    I have been called 2 times.

    I have been called 3 times.

转载来自:http://hi.baidu.com/embedtec/blog/item/fe1f3cdccac337abcd116694.html

1 基本解释

　　extern可以置于变量或者函数前，以标示变量或者函数的定义在别的文件中，提示编译器遇到此变量和函数时在其他模块中寻找其定义。

　　另外，extern也可用来进行链接指定。

2 问题：extern 变量

　　在一个源文件里定义了一个数组：char a[6];
　　在另外一个文件里用下列语句进行了声明：extern char *a；
　　请问，这样可以吗？