18.1.1 volatile的作用

volatile的作用是作为指令关键字，确保本条指令不会因编译器的优化而省略，且要求每次直接读值。

1)      编译器的优化

在本次线程内，当读取一个变量时，为提高存取速度，编译器优化时有时会先把变量读取到一个寄存器中；以后再取变量值时，就直接从寄存器中取值；

当变量值在本线程里改变时，会同时把变量的新值copy到该寄存器中，以便保持一致

当变量在因别的线程等而改变了值，该寄存器的值不会相应改变，从而造成应用程序读取的值和实际的变量值不一致

举个例子：

发薪资时，会计每次都把员工叫来登记他们的银行卡号；有一次，会计为了省事，没有即时登记，用了以前登记的银行卡号；刚好一个员工的银行卡丢了，已挂失该银行卡号；从而造成该员工领不到工资。

员工 －－ 原始变量地址

银行卡号 －－ 原始变量在寄存器的备份

18.1.2 #define DM9000_DBG(fmt,args...) printf(fmt, ##args)

标准C支持可变参数的函数，意味着函数的参数是不固定的，例如printf()函数的原型为：int printf( const char *format [, argument]... )

而在GNU C中，宏也可以接受可变数目的参数，例如：

#define DM9000_DBG(fmt,args...) printf(fmt, ##args)

这里args 表示其余的参数可以是零个或多个，这些参数以及参数之间的逗号构成arg 的值，在宏扩展时替换arg，例如下列代码：

DM9000_DBG("\n");

DM9000_DBG("NCR (0x00): %02x\n", DM9000_ior(0));

DM9000_DBG("rx status: 0x%04x rx len: %d\n", RxStatus, RxLen);

会被扩展为：

printf ("\n");

printf ("NCR   (0x00): %02x\n", DM9000_ior(0));

printf ("rx status: 0x%04x rx len: %d\n", RxStatus, RxLen);

18.1.3 字符转为数字

将ACSII转为数字需要-‘0’

#include“stdio.h”int main(){unsigned char c;while(1){    c = getchar();    putchar(c);    bank0 tacc_set(c - ‘0’);}return 0;} 

18.1.4 inline函数功能

GUN的C关键字，在函数定义中函数返回类型前加上关键字inline，可以把函数指定为内联函数。关键字inline必须与函数定义放在一起才能使函数成为内联，仅仅将inline放在函数声明前面不起任何作用。inline是一种“用于实现的关键字”，而不是一种“用于声明的关键字”。

在C&C++中，inline关键字用来定义一个类的内联函数，引入它的主要原因是用它替代C中表达式形式的宏定义。

表达式形式的宏定义：

cout<<shortString(s1,s2)<<endl;

在编译时展开为：

cout<<(s1.size() < s2.sizre() ? s1 : s2)<<endl;

inline优缺点：

1.inline定义的类的内联函数，函数的代码被放入符号表中，在使用时直接进行替换（像宏一样展开），没有了调用的开销，效率也很高。

2.由于将对函数的每一个调用都以函数本体替换之。所以会增加目标代码的大小。造成代码膨胀。这将导致程序体积太大，不利于在内存不大的机器上运行。

3. inline函数无法随着程序库的升级而升级。如果程序库中包含内联函数，一旦内联函数被改变，那么所有用到程序库的客户端程序都要重新编译。如果函数不是内联函数，一旦它有任何修改，客户端只需要重新连接就好。

18.1.5 sprintf函数功能

函数功能：把格式化的数据写入某个字符串

函数原型：int sprintf( char *buffer, const char *format [, argument] … );

返回值：字符串长度（strlen）

例子：

char* who = "I";

char* whom = "CSDN";

sprintf(s, "%s love %s.", who, whom); //产生："I love CSDN. "  这字符串写到s中

sprintf(s, "%10.3f", 3.1415626); //产生：" 3.142"

NOTE:这样就不会报错了

u8 text[20];

sprintf((char *)text, "-Value:%d", Value);

18.1.6 关键字extern

用#include可以包含其他头文件中变量、函数的声明，为什么还要extern关键字？

1.头文件

其实头文件对计算机而言没什么作用，只是在预编译时在#include的地方展开一下，没别的意义了。将头文件的后缀改成xxx.txt，然后在引用该头文件的地方用#include"xxx.txt"，编译、链接都很顺利的过去了，由此可知，头文件仅仅为阅读代码作用，没其他的作用了！

头文件就是对用户的说明。函数，参数，各种各样的接口的说明。

那既然是说明，那么头文件里面放的自然就是关于函数，变量，类的“声明”。

最好不要在头文件里定义什么东西。比如全局变量：

/*xx头文件*/

#ifndef _XX_头文件.H

#define _XX_头文件.H

int A;

#endif

那么，很糟糕的是，这里的int A是个全局变量的定义，所以如果这个头文件被多次引用的话，你的A会被重复定义，显然语法上错了。只不过有了这个#ifndef的条件编译，所以能保证你的头文件只被引用一次，不过也许还是不会出岔子，但若多个c文件包含这个头文件时还是会出错的，因为宏名有效范围仅限于本c源文件，所以在这多个c文件编译时是不会出错的，但在链接时就会报错，说你多处定义了同一个变量，

Linking...

incl2.obj : error LNK2005: "int glb" (?glb@@3HA) already defined in incl1.obj

Debug/incl.exe : fatal error LNK1169: one or more multiply defined symbols found

注意！！！

2.extern

对变量而言，如果你想在本源文件(例如文件名A)中使用另一个源文件(例如文件名B)的变量，方法有2种：

(1)在A文件中必须用extern声明在B文件中定义的变量(当然是全局变量)；

(2)在A文件中添加B文件对应的头文件，当然这个头文件包含B文件中的变量声明，也即在这个头文件中必须用extern声明该变量，否则，该变量又被定义一次。

对函数而言，如果你想在本源文件(例如文件名A)中使用另一个源文件(例如文件名B)的函数，方法有2种：

(1)在A文件中用extern声明在B文件中定义的函数(其实，也可省略extern，只需在A文件中出现B文件定义函数原型即可)；

(2)在A文件中添加B文件对应的头文件，当然这个头文件包含B文件中的函数原型，在头文件中函数可以不用加extern。

对上述总结换一种说法：

(a)对于一个文件中调用另一个文件的全局变量，因为全局变量一般定义在原文件.c中，我们不能用#include包含源文件而只能包含头文件，所以常用的方法是用extern  int a来声明外部变量。  

另外一种方法是可以是在a.c文件中定义了全局变量int global_num ，可以在对应的a.h头文件中写extern int global_num ，这样其他源文件可以通过include a.h来声明她是外部变量就可以了。

18.1.7 条件编译

18.1.7.1 #if 0…endif的用途

#if 0 ... #endif的作用和/*...*/的作用是一样的，就是注释！

可是注释为什么不用注释符号/*？

答：为了解决嵌套注释。如：

#include“stdio.h”int main(){　　int a=11；/*这是一个外层注释 　　/*   int *b=&a; //这是一个内层代码注释   *b = 10;   */   a++;*/}

上面的程序编译后发现缺少了一个注释符号，因为注释符头 " / *  "是根据最近结束符 " */  "来判断注释的区域的，但是一但内嵌了就会发现错误。所以人们就使用了#if 0。如下：

#include“stdio.h”int main(){　　int  a=11；/*这是一个外层注释#if  0  　　int *b=&a;  //这是一个内层代码注释　　*b = 10;#endif　　a++;*/}

在有些地方很常见到它，而且少不了它。当你见识过系统级的源代码就焕然大悟了。就是用于系统裁剪。

系统裁剪是针对系统的用途，对系统的源代码进行一下优化，减少不必要的功能。

#include“stdio.h”#define TEST_2 1int main(){　　int a=11；/*这是一个外层注释#if  TEST_2　　int *b=&a;　　*b = 10;#endif　　a++;*/}

如上面的例子，对于某些功能不需要，我们只需对于的功能TEST_2的宏定义改成0，然后重新编译就行了。当然一般宏定义是放在一个特定的.h文件，这样只需要更改那个文件所对应的值就行对系统进行裁剪而不需要关心具体代码。

18.1.7.2 #ifndef、#define、#endif的用途

看到很多程序的头文件写：

#ifndef HeaderName_h

#define HeaderName_h

//这里面通常写各种宏定义、其他头文件的包含

#endif

这样做的目的：防止该头文件被重复引用。

什么是“头文件被重复引用”？

答：其实“被重复引用”是指一个头文件在同一个cpp文件中被include了多次，这种错误常常是由于include嵌套造成的。

比如：存在a.h文件#include "c.h"，而b.cpp文件同时#include "a.h" 和#include "c.h"，此时就会造成c.h被b.cpp重复引用。

头文件被重复引用引起的后果：

有些头文件重复引用只是增加了编译工作的工作量，不会引起太大的问题，仅仅是编译效率低一些。但是对于大工程而言，编译效率低下那将是一件多么痛苦的事情。

而有些头文件重复包含，则会引起错误，比如：在头文件中定义了全局变量(虽然这种方式不被推荐，但确实是C规范允许的)，这种头文件重复包含会引起全局变量的重复定义。

18.1.8 结构体定义即其常用初始化方法

首先定义一个结构体：

法1：

typedef struct TestInit{    char *name;    int (*DeviceInit)(void);} T_TestInit;

　　在上面的代码中，实际上完成了两个操作：

　　1、定义了一个新的结构类型，代码如下所示：

struct TestInit{    char *name;    int (*DeviceInit)(void);};

　　其中，struct关键字和TestInit一起构成了这个结构类型，无论是否存在 typedef关键字，这个结构都存在。

　　2、使用typedef为这个新的结构起了一个别名，叫T_TestInit，即：

　　typedef struct TestInit T_TestInit;

　　声明一个结构体是时用 T_TestInit test；

法2：

struct TestInit{    char *name;    int (*DeviceInit)(void);};

　　声明一个结构体是时用 struct TestInit test;

初始化法1：定义时赋值

　　特点：按成员定义顺序，从前到后逐个初始化。不初始化的默认为0或NULL。

　　T_TestInit test = {"test"，IICDeviceInit}；

初始化法2：定义后逐个赋值

　　T_TestInit test；

　　test.name = "test";

　　test.DeviceInit = IICDeviceInit;

初始化法3：定义后乱序赋值，最常用的方法

　　特点：乱序的方式则很好的解决了按顺序初始化的问题，这种方式是按照成员名进行。

　　T_TestInit test = {

　　　　.name = "test",

　　　　.DeviceInit = IICDeviceInit,

　　}；

18.1.9 使用结构体的时候"->"和"."区别

　　定义的结构体如果是指针，访问成员时就用"->"

　　如果定义的是结构体变量，访问成员时就用"."

　　例如：

struct Test {    int i;    char c;};struct Test t; 访问成员就用：t.a;struct AAA *t; 访问成员就用：t->a;

 

---