C底层编程
来源：互联网 发布：sql create 唯一 编辑：程序博客网 时间：2024/06/01 10:12
水滴石穿C语言之C语言的底层操作
概述 C语言的内存模型基本上对应了现在von Neumann（冯·诺伊曼）计算机的实际存储模型，很好的达到了对机器的映射，这是C/C++适合做底层开发的主要原因，另外，C语言适合做底层开发还有另外一个原因，那就是C语言对底层操作做了很多的的支持，提供了很多比较底层的功能。
下面结合问题分别进行阐述。
问题：移位操作
在运用移位操作符时，有两个问题必须要清楚：
(1)、在右移操作中，腾空位是填 0 还是符号位；
(2)、什么数可以作移位的位数。
答案与分析：
">>"和"<<"是指将变量中的每一位向右或向左移动, 其通常形式为:
右移: 变量名>>移位的位数
左移: 变量名<<移位的位数
经过移位后, 一端的位被"挤掉",而另一端空出的位以0 填补,在C语言中的移位不是循环移动的。
(1) 第一个问题的答案很简单，但要根据不同的情况而定。如果被移位的是无符号数，则填 0 。如果是有符号数，那么可能填 0 或符号位。如果你想解决右移操作中腾空位的填充问题，就把变量声明为无符号型，这样腾空位会被置 0。
(2) 第二个问题的答案也很简单：如果移动 n 位，那么移位的位数要不小于 0 ，并且一定要小于 n 。这样就不会在一次操作中把所有数据都移走。
比如，如果整型数据占 32 位，n 是一整型数据，则 n << 31 和 n << 0 都合法，而 n << 32 和 n << -1 都不合法。
注意即使腾空位填符号位，有符号整数的右移也不相当与除以 。为了证明这一点，我们可以想一下 -1 >> 1 不可能为 0 。
问题：位段结构
struct RPR_ATD_TLV_HEADER
{
ULONG res1:6;
ULONG type:10;
ULONG res1:6;
ULONG length:10;
};
位段结构是一种特殊的结构, 在需按位访问一个字节或字的多个位时, 位结构比按位运算符更加方便。
位结构定义的一般形式为:
struct位结构名{
数据类型 变量名: 整型常数;
数据类型 变量名: 整型常数;
} 位结构变量;
其中: 整型常数必须是非负的整数, 范围是0~15, 表示二进制位的个数, 即表示有多少位。
变量名是选择项, 可以不命名, 这样规定是为了排列需要。
例如: 下面定义了一个位结构。
struct{
unsigned incon: 8;
unsigned txcolor: 4;
unsigned bgcolor: 3;
unsigned blink: 1;
}ch;
位结构成员的访问与结构成员的访问相同。
例如: 访问上例位结构中的bgcolor成员可写成:
ch.bgcolor
位结构成员可以与其它结构成员一起使用。按位访问与设置，方便&节省
例如:
struct info{
char name[8];
int age;
struct addr address;
float pay;
unsigned state: 1;
unsigned pay: 1;
}workers;
上例的结构定义了关于一个工从的信息。其中有两个位结构成员, 每个位结构成员只有一位, 因此只占一个字节但保存了两个信息, 该字节中第一位表示工人的状态, 第二位表示工资是否已发放。由此可见使用位结构可以节省存贮空间。
注意不要超过值限制
问题：字节对齐
让偶们先来看下面这个结构体:
struct stu1
{
};
怎么是8啊?
你先别急,再来看下一个例子:
struct
{
}
这个sizeof(stu2)是多少?
怎么还是8啊?
现在创建一个结构体变量 stu2 s2 {" a ", 0x12345678h}； stu1 s1 {0x12345678, " a "}
运行DEGUG,怎么样发现了什么?
在第一个结构体中char b的后面内存有三个字节是添了数据的.也就是这样 78 56 34 12 61 cc cc cc
而在第二个结构体中CHAR B的后面内存中也添加了数据.61 cc cc cc 78 56 34 12
这又是怎么回事呢?
需要字节对齐当然有设计者的考虑了，原来这样有助于加快计算机的存取速度，否则就得多花指令周期了。所以，编译器通常都会对结构体进行处理，让宽度为2的基本数据类型（short等）
都位于能被2整除的地址上，让宽度为4的基本数据类型（int等）都位于能被4整除的地址上。正是因为如此两个数中间就可能需要加入填充字节，所以结构体占的内存空间就增长了。
其实字节对齐的细节和具体编译器实现相关，但一般而言，满足三个准则：
1)
2) 结构体每个成员相对于结构体首地址的偏移量都是成员大小的整数倍，如有需要编译器会在成员之间加上填充字节；例如上面第二个结构体变量的地址空间。
现在就可以解释上面的问题了，第一个结构体变量中成员变量最宽为4(SIZEOF(INT) = 4)，所以S1变量首地址必须能被４整除。（不信你试试！）S1的大小也应该为4的整数倍。但是现在s1中有 4 + 1 的空间，所以为了满足第三个条件就在char b的后面在加上三个字节的空间以凑够8个字节空间。第二个结构体变量S2中 成员变量最大宽度为4，而且按照以前的理解int a 的地址和s2的地址相差5个字节，但是为了满足第而个条件（相差的距离------偏移地址必须是4的整数倍）所以在char b的后面添加了三个字节的空间以保证int a的偏移地址是4的整数倍即为4。至于涉及到结构体嵌套的问题，你也可以用上述方法总结的，只不过你把被嵌套的结构体在原地展开就行了，不过在计算偏移地址的时候被嵌套的结构体是不能原地展开的必须当作整体。嘿嘿！偶申明一点，上述三条建议不是偶说的，是做编译器的工程师总结出来的，偶只是借用而已。我在使用VC编程的过程中，有一次调用DLL中定义的结构时，发觉结构都乱掉了，完全不能读取正确的值，后来发现这是因为DLL和调用程序使用的字节对齐选项不同，那么我想问一下，字节对齐究竟是怎么一回事？
答案与分析：
为了能使CPU对变量进行高效快速的访问，变量的起始地址应该具有某些特性，即所谓的“对齐”。例如对于4字节的int类型变量，其起始地址应位于4字节边界上，即起始地址能够被4整除。
关于字节对齐：
1、 当不同的结构使用不同的字节对齐定义时，可能导致它们之间交互变得很困难。
2、 在跨CPU进行通信时，可以使用字节对齐来保证唯一性，诸如通讯协议、写驱动程序时候寄存器的结构等。
三种对齐方式：
1、 自然对齐方式（Natural Alignment）：与该数据类型的大小相等。
2、 指定对齐方式 ：
#pragma pack(8) //指定Align为 8；
#pragma pack() //恢复到原先值
3、 实际对齐方式：
Actual Align = min ( Order Align, Natual Align )
对于复杂数据类型（比如结构等）：实际对齐方式是其成员最大的实际对齐方式：
Actual Align = max( Actual align1,2,3，…)
编译器的填充规律：
1、 成员为成员Actual Align的整数倍，在前面加Padding。
成员Actual Align = min( 结构Actual Align，设定对齐方式)
2、 结构为结构Actual Align的整数倍，在后面加Padding.
例子分析：
#pragma pack(8) //指定Align为 8
struct STest1
{
char ch1;
long lo1;
char ch2;
} test1;
#pragma pack()
现在
Align of STest1 = 4 , sizeof STest1 = 12 ( 4 * 3 )
test1在内存中的排列如下（ FF 为 padding ）：
00 -- -- -- 04 -- -- -- 08 -- -- -- 12 -- -- --
01 FF FF FF 01 01 01 01 01 FF FF FF
ch1 -- lo1 -- ch2
#pragma pack(2) //指定Align为 2
struct STest2
{
char ch3;
STest1 test;
} test2;
#pragma pack()
现在 Align of STest1 = 2, Align of STest2 = 2 , sizeof STest2 = 14 ( 7 * 2 )
test2在内存中的排列如下：
00 -- -- -- 04 -- -- -- 08 -- -- -- 12 -- -- --
02 FF 01 FF FF FF 01 01 01 01 01 FF FF FF
ch3 ch1 -- lo1 -- ch2
注意事项：
1、 这样一来，编译器无法为特定平台做优化，如果效率非常重要，就尽量不要使用#pragma pack，如果必须使用，也最好仅在需要的地方进行设置。
2、 需要加pack的地方一定要在定义结构的头文件中加，不要依赖命令行选项，因为如果很多人使用该头文件，并不是每个人都知道应该pack。这特别表现在为别人开发库文件时，如果一个库函数使用了struct作为其参数，当调用者与库文件开发者使用不同的pack时，就会造成错误，而且该类错误很不好查。
3、 在VC及BC提供的头文件中，除了能正好对齐在四字节上的结构外，都加了pack，否则我们编的Windows程序哪一个也不会正常运行。
4、 在 #pragma pack(n) 后一定不要include其他头文件，若包含的头文件中改变了align值，将产生非预期结果。
5、 不要多人同时定义一个数据结构。这样可以保证一致的pack值。
问题：按位运算符
C语言和其它高级语言不同的是它完全支持按位运算符。这与汇编语言的位操作有些相似。 C中按位运算符列出如下:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
操作符 作用
────────────────────────────
& 位逻辑与
| 位逻辑或
^ 位逻辑异或
- 位逻辑反
>> 右移
<< 左移
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
注意：
1、按位运算是对字节或字中的实际位进行检测、设置或移位, 它只适用于字符型和整数型变量以及它们的变体, 对其它数据类型不适用。
2、关系运算和逻辑运算表达式的结果只能是1或0。 而按位运算的结果可以取0或1以外的值。要注意区别按位运算符和逻辑运算符的不同, 例如, 若x=7, 则x&&8 的值为真(两个非零值相与仍为非零), 而x&8的值为0。
3、 | 与 ||，&与&&，~与! 的关系
&、| 和 ~ 操作符把它们的操作数当作一个为序列，按位单独进行操作。比如：10 & 12 = 8，这是因为"&"操作符把 10 和 12 当作二进制描述 1010 和 1100 ，所以只有当两个操作数的相同位同时为 1 时，产生的结果中相应位才为 1 。同理，10 | 12 = 14 ( 1110 )，通过补码运算，~10 = -11 ( 11...110101 )。<以多少为一个位序列> &&、|| 和！操作符把它们的操作数当作"真"或"假"，并且用 0 代表"假"，任何非 0 值被认为是"真"。它们返回 1 代表"真"，0 代表"假"，对于"&&"和"||"操作符，如果左侧的操作数的值就可以决定表达式的值，它们根本就不去计算右侧的操作数。所以，!10 是 0 ，因为 10 非 0 ；10 && 12 是 1 ，因为 10 和 12 均非 0 ；10 || 12也是 1 ，因为 10 非 0 。并且，在最后一个表达式中，12 根本就没被计算，在表达式 10 || f( ) 中也是如此。
水滴石穿C语言之extern声明辨析
1 基本解释
extern可以置于变量或者函数前，以标示变量或者函数的定义在别的文件中，提示编译器遇到此变量和函数时在其他模块中寻找其定义。
另外，extern也可用来进行链接指定。
2 问题：extern 变量
在一个源文件里定义了一个数组：
char a[6];
在另外一个文件里用下列语句进行了声明：
extern char *a；
请问，这样可以吗？
答案与分析：
1)、不可以，程序运行时会告诉你非法访问。原因在于，指向类型T的指针并不等价于类型T的数组。extern char *a声明的是一个指针变量而不是字符数组，因此与实际的定义不同，从而造成运行时非法访问。应该将声明改为extern char a[ ]。
2)、例子分析如下，如果a[] = "abcd",则外部变量a=0x61626364 (abcd的ASCII码值)，*a显然没有意义，如下图：
显然a指向的空间（0x61626364）没有意义，易出现非法内存访问。
3)、这提示我们，在使用extern时候要严格对应声明时的格式，在实际编程中，这样的错误屡见不鲜。
4)、extern用在变量声明中常常有这样一个作用，你在*.c文件中声明了一个全局的变量，这个全局的变量如果要被引用，就放在*.h中并用extern来声明。
3 问题：extern 函数1
常常见extern放在函数的前面成为函数声明的一部分，那么，C语言的关键字extern在函数的声明中起什么作用？
答案与分析：
如果函数的声明中带有关键字extern，仅仅是暗示这个函数可能在别的源文件里定义，没有其它作用。即下述两个函数声明没有明显的区别：
extern int f(); 和int f();
当然，这样的用处还是有的，就是在程序中取代include “*.h”来声明函数，在一些复杂的项目中，我比较习惯在所有的函数声明前添加extern修饰。
4 问题：extern 函数2
当函数提供方单方面修改函数原型时，如果使用方不知情继续沿用原来的extern申明，这样编译时编译器不会报错。但是在运行过程中，因为少了或者多了输入参数，往往会照成系统错误，这种情况应该如何解决？
答案与分析：
目前业界针对这种情况的处理没有一个很完美的方案，通常的做法是提供方在自己的xxx_pub.h中提供对外部接口的声明，然后调用方include该头文件，从而省去extern这一步。以避免这种错误。
宝剑有双锋，对extern的应用，不同的场合应该选择不同的做法。
5 问题：extern “C”
在C++环境下使用C函数的时候，常常会出现编译器无法找到obj模块中的C函数定义，从而导致链接失败的情况，应该如何解决这种情况呢？
答案与分析：
C++语言在编译的时候为了解决函数的多态问题，会将函数名和参数联合起来生成一个中间的函数名称，而C语言则不会，因此会造成链接时找不到对应函数的情况，此时C函数就需要用extern “C”进行链接指定，这告诉编译器，请保持我的名称，不要给我生成用于链接的中间函数名。
下面是一个标准的写法：
//在.h文件的头上
#ifdef __cplusplus
#if __cplusplus
extern "C"{
#endif
#endif
…
…
//.h文件结束的地方
#ifdef __cplusplus
#if __cplusplus
}
#endif
#endif
水滴石穿C语言之static辨析
1、概述
static 声明的变量在C语言中有两方面的特征：
1)、变量会被放在程序的全局存储区中，这样可以在下一次调用的时候还可以保持原来的赋值。这一点是它与堆栈变量和堆变量的区别。
2)、变量用static告知编译器，自己仅仅在变量的作用范围内可见。这一点是它与全局变量的区别。
2、问题：Static的理解
关于static变量，请选择下面所有说法正确的内容：
A、若全局变量仅在单个C文件中访问，则可以将这个变量修改为静态全局变量，以降低模块间的耦合度；
B、若全局变量仅由单个函数访问，则可以将这个变量改为该函数的静态局部变量，以降低模块间的耦合度；
C、设计和使用访问动态全局变量、静态全局变量、静态局部变量的函数时，需要考虑重入问题；
D、静态全局变量过大，可那会导致堆栈溢出。
答案与分析：
对于A，B：根据本篇概述部分的说明b)，我们知道，A,B都是正确的。
对于C：根据本篇概述部分的说明a)，我们知道，C是正确的（所谓的函数重入问题，下面会详细阐述）。
对于D：静态变量放在程序的全局数据区，而不是在堆栈中分配，所以不可能导致堆栈溢出，D是错误的。
因此，答案是A、B、C。
3、问题：不可重入函数
曾经设计过如下一个函数，在代码检视的时候被提醒有bug，因为这个函数是不可重入的，为什么？
unsigned int sum_int( unsigned int base )
{
unsigned int index;
static unsigned int sum = 0; // 注意，是static类型的。
for (index = 1; index <= base; index++)
{
sum += index;
}
return sum;
}
答案与分析：
所谓的函数是可重入的（也可以说是可预测的），即：只要输入数据相同就应产生相同的输出。
这个函数之所以是不可预测的，就是因为函数中使用了static变量，因为static变量的特征，这样的函数被称为：带“内部存储器”功能的的函数。因此如果我们需要一个可重入的函数，那么，我们一定要避免函数中使用static变量，这种函数中的static变量，使用原则是，能不用尽量不用。
将上面的函数修改为可重入的函数很简单，只要将声明sum变量中的static关键字去掉，变量sum即变为一个auto 类型的变量，函数即变为一个可重入的函数。
当然，有些时候，在函数中是必须要使用static变量的，比如当某函数的返回值为指针类型时，则必须是static的局部变量的地址作为返回值，若为auto类型，则返回为错指针。
水滴石穿C语言之typedef的问题
1. 基本解释
typedef为C语言的关键字，作用是为一种数据类型定义一个新名字。这里的数据类型包括内部数据类型（int,char等）和自定义的数据类型（struct等）。
在编程中使用typedef目的一般有两个，一个是给变量一个易记且意义明确的新名字，另一个是简化一些比较复杂的类型声明。
至于typedef有什么微妙之处，请你接着看下面对几个问题的具体阐述。
2. typedef & 结构的问题
当用下面的代码定义一个结构时，编译器报了一个错误，为什么呢？莫非C语言不允许在结构中包含指向它自己的指针吗？请你先猜想一下，然后看下文说明：
typedef struct tagNode
{
char *pItem;
pNode pNext;
} *pNode;
答案与分析：
1、typedef的最简单使用
typedef long byte_4;
给已知数据类型long起个新名字，叫byte_4。
2、 typedef与结构结合使用
typedef struct tagMyStruct
{
int iNum;
long lLength;
} MyStruct;
这语句实际上完成两个操作：
1) 定义一个新的结构类型
struct tagMyStruct
{
int iNum;
long lLength;
};
分析：tagMyStruct称为“tag”，即“标签”，实际上是一个临时名字，struct 关键字和tagMyStruct一起，构成了这个结构类型，不论是否有typedef，这个结构都存在。
我们可以用struct tagMyStruct varName来定义变量，但要注意，使用tagMyStruct varName来定义变量是不对的，因为struct 和tagMyStruct合在一起才能表示一个结构类型。
2) typedef为这个新的结构起了一个名字，叫MyStruct。
typedef struct tagMyStruct{ } MyStruct；
因此，MyStruct实际上相当于struct tagMyStruct，我们可以使用MyStruct varName来定义变量。
答案与分析
C语言当然允许在结构中包含指向它自己的指针，我们可以在建立链表等数据结构的实现上看到无数这样的例子，上述代码的根本问题在于typedef的应用。
根据我们上面的阐述可以知道：新结构建立的过程中遇到了pNext域的声明，类型是pNode，要知道pNode表示的是类型的新名字，那么在类型本身还没有建立完成的时候，这个类型的新名字也还不存在，也就是说这个时候编译器根本不认识pNode。
解决这个问题的方法有多种：
1)、
typedef struct tagNode
{
char *pItem;
struct tagNode *pNext;
} *pNode;
2)、
typedef struct tagNode *pNode;
struct tagNode
{
char *pItem;
pNode pNext;
};
注意：在这个例子中，你用typedef给一个还未完全声明的类型起新名字。C语言编译器支持这种做法。
3)、规范做法：
struct tagNode
{
char *pItem;
struct tagNode *pNext;
};
typedef struct tagNode *pNode；
3.
有下面两种定义pStr数据类型的方法，两者有什么不同？哪一种更好一点？
typedef char *pStr;
#define pStr char *;
答案与分析：
通常讲，typedef要比#define要好，特别是在有指针的场合。请看例子：
typedef char *pStr1;
#define pStr2 char *;
pStr1 s1, s2;
pStr2 s3, s4;
在上述的变量定义中，s1、s2、s3都被定义为char *，而s4则定义成了char，不是我们所预期的指针变量，根本原因就在于#define只是简单的字符串替换而typedef则是为一个类型起新名字。
#define用法例子：
＃define f(x) x*x
main( )
{
int a=6，b=2，c；
c=f(a) / f(b)；
printf("%d \n"，c)；
}
以下程序的输出结果是: 36。
因为如此原因，在许多C语言编程规范中提到使用#define定义时，如果定义中包含表达式，必须使用括号，则上述定义应该如下定义才对：
#define f(x) (x*x)
当然，如果你使用typedef就没有这样的问题。
4. typedef & #define的另一例
下面的代码中编译器会报一个错误，你知道是哪个语句错了吗？
typedef char * pStr;
char string[4] = "abc";
const char *p1 = string;
const pStr p2 = string;
p1++;
p2++;
答案与分析：
是p2++出错了。这个问题再一次提醒我们：typedef和#define不同，它不是简单的文本替换。上述代码中const pStr p2并不等于const char * p2。const pStr p2和const long x本质上没有区别，都是对变量进行只读限制，只不过此处变量p2的数据类型是我们自己定义的而不是系统固有类型而已。因此，const pStr p2的含义是：限定数据类型为char *的变量p2为只读，因此p2++错误。
（注：关于const的限定内容问题，在本系列第二篇有详细讲解）。
#define与typedef引申谈
1) #define宏定义有一个特别的长处：可以使用 #ifdef ,#ifndef等来进行逻辑判断，还可以使用#undef来取消定义。
2) typedef也有一个特别的长处：它符合范围规则，使用typedef定义的变量类型其作用范围限制在所定义的函数或者文件内（取决于此变量定义的位置），而宏定义则没有这种特性。
5. typedef & 复杂的变量声明
在编程实践中，尤其是看别人代码的时候，常常会遇到比较复杂的变量声明,使用typedef作简化自有其价值，比如：
下面是三个变量的声明，我想使用typdef分别给它们定义一个别名，请问该如何做？
>1：int *(*a[5])(int, char*);
>2：void (*b[10]) (void (*)());
>3. doube(*)() (*pa)[9];
答案与分析：
对复杂变量建立一个类型别名的方法很简单，你只要在传统的变量声明表达式里用类型名替代变量名，然后把关键字typedef加在该语句的开头就行了。
（注：如果你对有些变量的声明语法感到难以理解，请参阅本系列第十篇的相关内容）。
>1：int *(*a[5])(int, char*);
//pFun是我们建的一个类型别名
typedef int *(*pFun)(int, char*);
//使用定义的新类型来声明对象，等价于int* (*a[5])(int, char*);
pFun a[5];
>2：void (*b[10]) (void (*)());
//首先为上面表达式蓝色部分声明一个新类型
typedef void (*pFunParam)();
//整体声明一个新类型
typedef void (*pFun)(pFunParam);
//使用定义的新类型来声明对象，等价于void (*b[10]) (void (*)());
pFun b[10];
>3. doube(*)() (*pa)[9];
//首先为上面表达式蓝色部分声明一个新类型
typedef double(*pFun)();
//整体声明一个新类型
typedef pFun (*pFunParam)[9];
//使用定义的新类型来声明对象，等价于doube(*)() (*pa)[9];
pFunParam pa;
水滴石穿C语言之编译器引出的问题
本节主要探讨C编译器下面两方面的特点所引发的一系列常见的编程问题。
·
C程序通常由几个小程序（.c文件）组成，编译器将这几个小程序分别编译，然后通过链接程序将它们组合在一起形成一个目标代码。由于编译器每次只能编译一个文件，因此它不能立即检查需要几个源文件配合才能发现的错误。
·
C编译器会对函数的参数建立临时参数，也可能会对函数的返回值隐含传递一个指针。因为这些临时变量的隐含性存在，使得在某些情况下，特别是有指针存在的时候，会引发一系列的问题。
·
C语言中被包含的头文件是和.c文件一起编译的，头文件中的问题会反映到.c文件的编译中。
问题：C文件的分别编译
我有一个数组a定义在f1.c中，但是我想在f2.c中计算它的元素个数，用sizeof可以达到这个目的吗？
答案与分析：
答案是否定的，你没有办法达到目的，本质原因是sizeof操作符只是在“编译时（compile time）”起作用，而C语言的编译单位是每次单个.c文件进行编译（其它语言也都如此）。因此，sizeof可以确定同一个源文件中某个数组的大小，但是对于定义在另一个源文件中的数组它无能为力了，因为那已经是“运行时（run time）”才能确定的事情了。
一件事情要想做，总会有办法的，下面提供有三种可选的办法来解决这个问题：
1)、定义一个全局变量，让它记住数组的大小，在另外一个.c文件中我们通过访问这个全局变量来得到数组的大小信息（好像有点小题大做得不偿失^_^）。
2)、在某个.h文件中用宏定义数组的大小，例如#define ARRAY_SIZE 50，然后在两个源文件中都包含这个.h文件，通过直接访问ARRAY_SIZE来得到定义在不同.c文件中的数组的大小。
3)、设置数组的最后一个元素为特殊值，例如0，-1，NULL等，然后我们通过遍历数组来寻找这个特殊的结尾元素，从而判断数组的长度（这个办法效率低，也是笨笨的）。
问题：函数返回值隐含传递指针
下面的代码可以正常工作，但是在程序结束时会有一个致命错误产生。究竟是什么原因呢?
struct list
{
char *item;
struct list *next;
}
main (argc, argv)
{
...
}
答案与分析：
原因很简单，稍微注意一点不难发现，在定义结构list的右花括弧后面加一个分号就可以解决这个问题：
struct list
{
char *item;
struct list *next;
}；//缺了这个分号可不行！
好了，问题是解决了，但，你知道这个错误究竟导致了什么致命问题吗？问题不是表面上那么简单的，OK，让我们来看看事情背后的真相。
首先看一看下面这段代码：
VOID Func ( struct my_struct stX)
{
.......
}
struct my_struct stY = {...};
Func (stY);
当调用函数Func的时候，是把结构变量stY的值拷贝一份到调用栈中，从而作为参数传递给函数FUNC的，这个叫做C语言的参数值传递。我相信这个你一定很清楚，那么，你应该知道：如果函数的返回值是结构变量的话，函数应该如何将值返回给调用者呢？且看下面这段代码：
struct my_structFunc (VOID)
{
.......
}
struct my_struct stY = Func();
此时函数Func的返回值是一个结构类型的值，这个返回值被放在内存中一个阴暗恐怖的地方，同时安排了一个指针指向这个地方（暂时称为“神秘指针”），而这个指针会由C语言的编译器作为一个隐藏参数传递给函数Func。当函数Func返回时，编译器生成的代码将这个由隐藏指针指向的内存区的值拷贝到返回结构stY中，从而完成将结构变量值返回给调用者。
你明白了上述所讲的东东，那么今天问题的真正原因也就呼之欲出了：
因为struct list {...}的定义后面没有加分号，导致主函数main (argc, argv)被编译器理解为是一个返回值为结构变量的函数，从而期望得到除了argc和argv以外的第三个参数，也就是我们上面提到的那个隐含传入的“神秘指针”。可是，大家知道，这里函数是main函数，main函数的参数是由程序中的启动代码（startup code）提供的。而启动代码当然认为main()天生就应该只得到两个参数，要“神秘指针”，当然没有，如此一来， main()在返回时自作主张地去调用栈中访问它的那个并不存在的第三个参数（即神秘指针），这样导致非法访问，产生致命问题。这才是这个问题的真正根源。
建议：
1)、尽量将结构变量的指针而不是结构本身作为函数参数，否则函数调用时内存拷贝的开销可不小，尤其是对那些调用频繁、结构体大的情况。
2)、结构定义的后面一定要加分号，经过上面我的大段讲述，我相信你不会犯相同的错误
问题：编译器会给函数的参数隐含制造临时副本
请问运行下面的Test函数会有什么样的结果？
void GetMemory2(char **p, int num)
{
*p = (char *)malloc(num);
}
void Test(void)
{
char *str = NULL;
GetMemory(&str, 100);
strcpy(str, "hello");
printf(str);
}
答案与分析：
这是林锐的《C/C++高质量编程指南》上面的例子，拿来用一下。
这样调用会产生如下两个后果：
1)、能够输出hello
2)、内存泄漏
另一个相关问题：
请问运行Test函数会有什么样的结果？
void GetMemory(char *p)
{
p = (char *)malloc(100);
}
void Test(void)
{
char *str = NULL;
GetMemory(str);
strcpy(str, "hello world");
printf(str);
}
答案与分析：
后果严重，运行的结果是程序崩溃，通过运行调试我们可以看到，经过GetMemory后，Test函数中的 str仍旧是NULL。可想而知，一调用
strcpy(str, "hello world");
程序必然崩溃了事。
原因分析：
C编译器总是会为函数的每个参数制作临时副本，指针参数p的副本是 _p，编译器使 _p = p。如果函数体内的程序修改了_p的内容，就导致参数p的内容作相应的修改。这就是指针可以用作输出参数的原因。在本例中，_p申请了新的内存，只是把_p所指的内存地址改变了，但是p丝毫未变。所以函数GetMemory并不能输出任何东西，如果想要输出动态内存，请使用指向指针的指针，或者，使用指向引用的指针。
问题：头文件和包含它的.c文件一同编译问
下面的代码非常短小，看起来毫无问题，但编译器会报告一个错误，请问问题可能出现在什么地方？
#include "someheader.h"
int myint = 0;
答案与分析：
不用盯着int myint = 0;看，这一句赋值应该是C语言中最简单的语句，问题肯定不会出在它身上，那么问题只可能出现在someheader.h中，最常见的就是该头文件的最后一行的声明（函数也好，变量也好）没有用分号";"结尾，那么编译器会将它和myint变量结合起来考虑，自然就会出错了。
这个问题主要是提醒你，在定位问题时思路要拓宽一点，可能要考虑一下所包含的头文件是否有问题。
结论：被包含的头文件是和.c文件一起编译的，头文件中的问题会反映到.c文件编译中去的，切记。
水滴石穿C语言之可变参数问题
概述
C语言中有一种长度不确定的参数，形如："…"，它主要用在参数个数不确定的函数中，我们最容易想到的例子是printf函数。
原型：
int printf( const char *format [, argument]... );
使用例：
printf("Enjoy yourself everyday!\n");
printf("The value is %d!\n", value);
这种可变参数可以说是C语言一个比较难理解的部分，这里会由几个问题引发一些对它的分析。
注意：在C++中有函数重载（overload）可以用来区别不同函数参数的调用，但它还是不能表示任意数量的函数参数。
问题：printf的实现
请问，如何自己实现printf函数，如何处理其中的可变参数问题？ 答案与分析：
在标准C语言中定义了一个头文件<stdarg.h>专门用来对付可变参数列表，它包含了一组宏，和一个va_list的typedef声明。一个典型实现如下：
typedef char* va_list;
#define va_start(list) list = (char*)&va_alist
#define va_end(list)
#define va_arg(list, mode)\
((mode*) (list += sizeof(mode)))[-1]
自己实现printf：
#include <stdarg.h>
int printf(char* format, …)
{
va_list ap;
va_start(ap, format);
int n = vprintf(format, ap);
va_end(ap);
return n;
}
问题：运行时才确定的参数
有没有办法写一个函数，这个函数参数的具体形式可以在运行时才确定？
答案与分析：
目前没有"正规"的解决办法，不过独门偏方倒是有一个，因为有一个函数已经给我们做出了这方面的榜样，那就是main()，它的原型是:
int main(int argc,char *argv[]);
函数的参数是argc和argv。
深入想一下，"只能在运行时确定参数形式"，也就是说你没办法从声明中看到所接受的参数，也即是参数根本就没有固定的形式。常用的办法是你可以通过定义一个void *类型的参数，用它来指向实际的参数区，然后在函数中根据根据需要任意解释它们的含义。这就是main函数中argv的含义，而argc，则用来表明实际的参数个数，这为我们使用提供了进一步的方便，当然，这个参数不是必需的。
虽然参数没有固定形式，但我们必然要在函数中解析参数的意义，因此，理所当然会有一个要求，就是调用者和被调者之间要对参数区内容的格式，大小，有效性等所有方面达成一致，否则南辕北辙各说各话就惨了。
问题：可变长参数的传递
有时候，需要编写一个函数，将它的可变长参数直接传递给另外的函数，请问，这个要求能否实现？
答案与分析：
目前，你尚无办法直接做到这一点，但是我们可以迂回前进，首先，我们定义被调用函数的参数为va_list类型，同时在调用函数中将可变长参数列表转换为va_list，这样就可以进行变长参数的传递了。看如下所示：
void subfunc (char *fmt, va_list argp)
{
...
arg = va_arg (fmt, argp);
...
}
void mainfunc (char *fmt, ...)
{
va_list argp;
va_start (argp, fmt);
subfunc (fmt, argp);
va_end (argp);
...
}
问题：可变长参数中类型为函数指针
我想使用va_arg来提取出可变长参数中类型为函数指针的参数，结果却总是不正确，为什么？
答案与分析：
这个与va_arg的实现有关。一个简单的、演示版的va_arg实现如下：
#define va_arg(argp, type) \
(*(type *)(((argp) += sizeof(type)) - sizeof(type)))
其中，argp的类型是char *。
如果你想用va_arg从可变参数列表中提取出函数指针类型的参数，例如
int (*)()，则va_arg(argp, int (*)())被扩展为：
(*(int (*)() *)(((argp) += sizeof (int (*)())) -sizeof (int (*)())))
显然，（int (*)() *）是无意义的。
解决这个问题的办法是将函数指针用typedef定义成一个独立的数据类型，例如：
typedef int (*funcptr)()；
这时候再调用va_arg(argp, funcptr)将被扩展为：
(* (funcptr *)(((argp) += sizeof (funcptr)) - sizeof (funcptr)))
这样就可以通过编译检查了。
问题：可变长参数的获取
有这样一个具有可变长参数的函数，其中有下列代码用来获取类型为float的实参：
va_arg (argp, float);
这样做可以吗？
答案与分析：
不可以。在可变长参数中，应用的是"加宽"原则。也就是float类型被扩展成double；char, short被扩展成int。因此，如果你要去可变长参数列表中原来为float类型的参数，需要用va_arg(argp, double)。对char和short类型的则用va_arg(argp, int)。
问题：定义可变长参数的一个限制
为什么我的编译器不允许我定义如下的函数，也就是可变长参数，但是没有任何的固定参数？
int f (...)
{
...
}
答案与分析：
不可以。这是ANSI C 所要求的，你至少得定义一个固定参数。
这个参数将被传递给va_start()，然后用va_arg()和va_end()来确定所有实际调用时可变长参数的类型和值。
水滴石穿C语言之内存使用
问题：内存使用
有人写了一个将整数转换为字符串的函数：
char *itoa (int n)
{
char retbuf[20];
sprintf(retbuf, "%d", n);
return retbuf;
}
如果我调用这个函数：char *str5 = itoa(5)，str5会是什么结果呢？
答案分析：
答案是不确定，可以确定的是肯定不是我们想要的 “5”。
retbuf定义在函数体中，是一个局部变量，它的内存空间位于栈（stack）中的某个位置，其作用范围也仅限于在itoa()这个函数中。当itoa()函数退出时，retbuf在调用栈中的内容将被收回，这时，这块内存地址可能存放别的内容。因此将retbuf这个局部变量返回给调用者是达不到预期的目的的。
那么如何解决这个问题呢，不用担心，方法不但有，而且还不止一个，下面就来阐述三种能解决这个问题的办法：
1)、在itoa()函数内部定义一个static char retbuf[20]，根据静态变量的特性，我们知道，这可以保证函数返回后retbuf的空间不会被收回，原因是函数内的静态变量并不是放在栈中，而是放在程序中一个叫“.bss”段的地方，这个地方的内容是不会因为函数退出而被收回的。
这种办法确实能解决问题，但是这种办法同时也导致了itoa()函数变成了一个不可重入的函数（即不能保证相同的输入肯定有相同的输出），另外， retbuf [] 中的内容会被下一次的调用结果所替代，这种办法不值得推荐。
2)、在itoa()函数内部用malloc() 为retbuf申请内存，并将结果存放其中，然后将retbuf返回给调用者。由于此时retbuf位于堆（heap）中，也不会随着函数返回而释放，因此可以达到我们的目的。
但是有这样一种情况需要注意：itoa()函数的调用者在不需要retbuf的时候必须把它释放，否则就造成内存泄漏了，如果此函数和调用函数都是同一个人所写，问题不大，但如果不是，则比较容易会疏漏此释放内存的操作。
3)、将函数定义为char *itoa（int n， char *retbuf），且retbuf的空间由调用者申请和释放，itoa()只是将转换结果存放到retbuf而已。
这种办法明显比第一、二种方法要好，既避免了方法1对函数的影响，也避免了方法2对内存分配释放的影响，是目前一种比较通行的做法。
扩展分析：
其实就这个问题本身而言，我想大家都可以立刻想到答案，关键在于对内存这种敏感资源的正确和合理地利用，下面对内存做一个简单的分析：
1)、程序中有不同的内存段，包括：
.data - 已初始化全局/静态变量，在整个软件执行过程中有效；
.bss - 未初始化全局/静态变量，在整个软件执行过程中有效；
.stack - 函数调用栈，其中的内容在函数执行期间有效，并由编译器负责分配和收回；
.heap - 堆，由程序显式分配和收回，如果不收回就是内存泄漏。
2)、自己使用的内存最好还是自己申请和释放。
这可以说是一个内存分配和释放的原则，比如说上面解决办法的第二种，由itoa()分配的内存，最后由调用者释放，就不是一个很好的办法，还不如用第三种，由调用者自己申请和释放。另外这个原则还有一层意思是说：如果你要使用一个指针，最好先确信它已经指向合法内存区了，如果没有就得自己分配，要不就是非法指针访问。很多程序的致命错误都是访问一个没有指向合法内存区的指针，这也包括空指针。
问题：内存分配 & sizeof
我使用sizeof来计算一个指针变量，我希望得到这个指针变量所分配的内存块的大小，可以吗？
Char *p = NULL;
int nMemSize = 0;
…
p = malloc(1024);
nMemSize = sizeof(p);
答案与分析：
答案是达不到你的要求，sizeof只能告诉你指针本身占用的内存大小。指针所指向的内存，如果是malloc分配的，sizeof 是没有办法知道的。换句话说，malloc分配的内存是没有办法向内存管理模块进行事后查询的，当然你可以自己编写代码来维护。
问题：栈内存使用
下面程序运行有什么问题？
char *GetString(void)
{
char p[] = "hello world";
return p;// 编译器将提出警告
}
void Test4(void)
{
char *str = NULL;
str = GetString();// str 的内容是垃圾
cout<< str << endl;
}
答案与分析：
返回栈内存，内存可能被销毁，也可能不被销毁，但是，出了作用域之后已被标记成可被系统使用，所以，乱七八糟不可知内容，当然，返回的指针的内容，应该是不变的，特殊时候是有用的，比如，可以用来探测系统内存分配规律等等。
问题：内存使用相关编程规范
我想尽可能地避免内存使用上的问题，有什么捷径吗？
答案与分析：
除非做一件从没有人做过的事情，否则，都是有捷径可言的，那就是站在前人的肩膀上，现在各个大公司都有自己的编码规范，这些规范凝聚了很多的经验和教训，有较高的使用价值，鉴于这些规范在网上流传很多，这里我就不再列出了，感兴趣的，推荐参考林锐的《高质量C/C++编程指南》。
水滴石穿C语言之声明的语法
概述
在很多情况下，尤其是读别人所写代码的时候，对C语言声明的理解能力变得非常重要，而C语言本身的凝练简约也使得C语言的声明常常会令人感到非常困惑，因此，在这里我用一篇的内容来集中阐述一下这个问题。
问题：声明与函数
有一段程序存储在起始地址为0的一段内存上，如果我们想要调用这段程序，请问该如何去做？
答案
答案是(*(void (*)( ) )0)( )。看起来确实令人头大，那好，让我们知难而上，从两个不同的途径来详细分析这个问题。
答案分析：从尾到头
首先，最基本的函数声明：void function (paramList);
最基本的函数调用：function(paramList);
鉴于问题中的函数没有参数，函数调用可简化为 function();
其次，根据问题描述，可以知道0是这个函数的入口地址，也就是说，0是一个函数的指针。使用函数指针的函数声明形式是：void (*pFunction)()，相应的调用形式是： (*pFunction)()，则问题中的函数调用可以写作：(*0)( )。
第三，大家知道，函数指针变量不能是一个常数，因此上式中的0必须要被转化为函数指针。
我们先来研究一下，对于使用函数指针的函数：比如void (*pFunction)( )，函数指针变量的原型是什么？这个问题很简单，pFunction函数指针原型是( void (*)( ) )，即去掉变量名，清晰起见，整个加上（）号。
所以将0强制转换为一个返回值为void，参数为空的函数指针如下：( void (*)( ) )。
OK，结合2)和3)的分析，结果出来了，那就是：(*(void (*)( ) )0)( ) 。
答案分析：从头到尾理解答案
(void (*)( )) ，是一个返回值为void，参数为空的函数指针原型。
(void (*)( ))0，把0转变成一个返回值为void，参数为空的函数指针，指针指向的地址为0.
*(void (*)( ))0，前面加上*表示整个是一个返回值为void的函数的名字
(*(void (*)( ))0)( )，这当然就是一个函数了。
我们可以使用typedef清晰声明如下：
typedef void (*pFun)( );
这样函数变为 (*(pFun)0 )( );
问题：三个声明的分析
对声明进行分析，最根本的方法还是类比替换法，从那些最基本的声明上进行类比，简化，从而进行理解，下面通过分析三个例子，来具体阐述如何使用这种方法。
＃1：int* (*a[5])(int, char*);
首先看到标识符名a，“[]”优先级大于“*”，a与“[5]”先结合。所以a是一个数组，这个数组有5个元素，每一个元素都是一个指针，指针指向“(int, char*)”，很明显，指向的是一个函数，这个函数参数是“int, char*”，返回值是“int*”。OK，结束了一个。：）
＃2：void (*b[10]) (void (*)());
b是一个数组，这个数组有10个元素，每一个元素都是一个指针，指针指向一个函数，函数参数是“void (*)()”【注10】，返回值是“void”。完毕！
注意：这个参数又是一个指针，指向一个函数，函数参数为空，返回值是“void”。
＃3. doube(*)() (*pa)[9];
pa是一个指针，指针指向一个数组，这个数组有9个元素，每一个元素都是“doube(*)()”（也即一个函数指针，指向一个函数，这个函数的参数为空，返回值是“double”）。
水滴石穿C语言之正确使用const
基本解释
const是一个C语言的关键字，它限定一个变量不允许被改变。使用const在一定程度上可以提高程序的健壮性，另外，在观看别人代码的时候，清晰理解const所起的作用，对理解对方的程序也有一些帮助。
虽然这听起来很简单，但实际上，const的使用也是c语言中一个比较微妙的地方，微妙在何处呢？请看下面几个问题。
问题：const变量 & 常量
为什么我象下面的例子一样用一个const变量来初始化数组，ANSI C的编译器会报告一个错误呢？
const int n = 5;
int a[n];
答案与分析:
1）、这个问题讨论的是“常量”与“只读变量”的区别。常量肯定是只读的，例如5， “abc”，等，肯定是只读的，因为程序中根本没有地方存放它的值，当然也就不能够去修改它。而“只读变量”则是在内存中开辟一个地方来存放它的值，只不过这个值由编译器限定不允许被修改。C语言关键字const就是用来限定一个变量不允许被改变的修饰符（Qualifier）。上述代码中变量n被修饰为只读变量，可惜再怎么修饰也不是常量。而ANSI C规定数组定义时维度必须是“常量”，“只读变量”也是不可以的。
2)、注意：在ANSI C中，这种写法是错误的，因为数组的大小应该是个常量，而const int n,n只是一个变量（常量 != 不可变的变量，但在标准C++中，这样定义的是一个常量，这种写法是对的），实际上，根据编译过程及内存分配来看，这种用法本来就应该是合理的，只是ANSI C对数组的规定限制了它。
3)、那么，在ANSI C 语言中用什么来定义常量呢？答案是enum类型和#define宏，这两个都可以用来定义常量。
问题：const变量 & const 限定的内容
下面的代码编译器会报一个错误，请问，哪一个语句是错误的呢？
typedef char * pStr;
char string[4] = "abc";
const char *p1 = string;
const pStr p2 = string;
p1++;
p2++;
答案与分析：
问题出在p2++上。
1)、const使用的基本形式： const char m;
限定m不可变。
2)、替换1式中的m, const char *pm;
限定*pm不可变，当然pm是可变的，因此问题中p1++是对的。
3)、替换1式char, const newType m;
限定m不可变，问题中的charptr就是一种新类型，因此问题中p2不可变，p2++是错误的。
问题：const变量 & 字符串常量
请问下面的代码有什么问题？
char *p = "i'm hungry!";
p[0]= 'I';
答案与分析：
上面的代码可能会造成内存的非法写操作。分析如下， “i'm hungry”实质上是字符串常量，而常量往往被编译器放在只读的内存区，不可写。p初始指向这个只读的内存区，而p[0] = 'I'则企图去写这个地方，编译器当然不会答应。
问题：const变量 & 字符串常量2
请问char a[3] = "abc" 合法吗？使用它有什么隐患？
答案与分析：
在标准C中这是合法的，但是它的生存环境非常狭小；它定义一个大小为3的数组，初始化为“abc”，，注意，它没有通常的字符串终止符'\0'，因此这个数组只是看起来像C语言中的字符串，实质上却不是，因此所有对字符串进行处理的函数，比如strcpy、printf等，都不能够被使用在这个假字符串上。
问题5：const & 指针
类型声明中const用来修饰一个常量，有如下两种写法，那么，请问，下面分别用const限定不可变的内容是什么?
1)、const在前面
const int nValue； //nValue是const
const char *pContent; /
x = *p;
p = &a;
问题：函数指针与指针函数
请问：如下定义是什么意思：
int *pF1();
int (*pF2)();
答案与分析：
首先清楚它们的定义：
指针函数，返回一个指针的函数。
函数指针，指向一个函数的指针。
可知：
pF1是一个指针函数，它返回一个指向int型数据的指针。
pF2是一个函数指针，它指向一个参数为空的函数，这个函数返回一个整数。
水滴石穿C语言之指针步进辨析
基本解释
通过上一篇的分析，我们已经很清楚地知道：指针不是一个简单的类型，它是一个本身和所指向物相复合的类型。指针的算术运算（如步进）与指针所指向物的类型密切相关。
问题：指针步进 & 步进单位
下面的代码中打印出的结果是几？
int arContext[5] ={0,1,2,3,4}, i, *pAr;
pAr = arContext;
printf ("%d\n", *(pAr + 3 * sizeof (int)));
答案与分析：
这段代码没有正确答案，因为这段代码是错的，printf将打出无法预测的内存区的值，其中的原因如下：
在C语言中，指针总是按照它所指向的对象的大小步进。在上面的例子中，pAr是指向整数类型变量的指针，一个整数是4个字节（默认CPU字长是32位），pAr + 1就指向下一个整数，也就是指针后移4个字节，而不是说将地址只移动一个字节。
因为C语言编译器知道每个指针的类型，因此对指针的运算是会自动把所指类型的Size考虑进去的。
pAr + 3 * sizeof (int) = pAr + 3 * 4 = pAr + 12 ，因此pAr指向了数组的第13个整数元素。而数组本身才5个元素，pAr早已经超出了界限，所指向的地方当然就是无人可知道的东西了，具体指向什么东西，各种不同的编译器互不相同。总之，肯定不能打印出我们想要的值就是了。
指针不是一个简单的类型，它是一个和指针所指物的类型相复合的类型。因此，它的算术运算与指针所指物的类型密切相关，在C++语言中也是同样。
再比如下面的例子：
int a[8];
int* p = a;
int* q = p + 3;
p++;
指针的加减并不是指针本身的二进制表示加减，要记住，指针是一个元素的地址，它每加一次，就指向下一个元素。所以：
int* q = p + 3;
q指向从p开始的第三个整数。
p++;
p指向下一个整数。
问题：指针步进 & 步进单位转换
我有一个char *类型的指针，恰好指向了一个int类型的值，我想让这个指针跳过int指向下一个char，下面的代码可以达到这个目的吗？
((int *)p)++;
答案与分析：
可以。
首先我们要清楚Ｃ语言中左值和右值的概念，C语言中左值是指可以放在“=”左侧，即可以被赋值，右值是可以放在“=”的右边，即可以赋给其它变量的值。++是单目操作符，它将一个变量的值加1然后再赋给这个变量，因此它需要的操作数应该既可以放在“=”号的左边，也可以放在“=”的右边。原则上讲，类型强制转换的结果是右值而不是左值。所以，(int *)p的结果在这个表达式中是++的右值，而++的左值依旧是p，而不是(int *)p。
这个问题的核心正是告诉我们类型强制转换的结果是右值而不是左值。
另外，我们可以使用一个简单的办法达到相同的目的：
p += sizeof(int)；
p是char *类型的指针，它的步进长度是1，加上一个整数所占的长度，就是跳过了一个整数所占的空间。
所以，有时候，ULONG *p; 想要增加8个字节，可以作如下强制转换：
(ULONG *)((UCHAR *)p+8
问题：指针步进 & void 指针
为什么我对void *类型的指针进行运算，编译器会报告如下错误？
error C2036: 'void *' : unknown size
答案与分析：
在C语言中，所有的指针运算，例如+、—、*、/，都是将它所指向的对象的尺寸考虑进取的。例如‘char*’ 类型的指针加1，就是地址向后移动一个字节；而‘int*’类型指针加1，就是移动4个字节。但是，对于‘void*’型的指针呢？‘void *’指针在Ｃ标准中被规定可以强制转换成任何类型的指针而不会丢失数据，它的大小具体的编译器各不相同，也就是说，编译器也不知道void到底有多大，因此，无法对‘void*’类型的指针进行算术运算。
水滴石穿C语言之指针综合谈
概述
Joel Spolsky认为，对指针的理解是一种aptitude，不是通过训练就可以达到的。虽然如此，我还是想谈一谈这个C/C++语言中最强劲也是最容易出错的要素。
鉴于指针和目前计算机内存结构的关联，很多C语言比较本质的特点都孕育在其中，因此，本篇和第六、第七两篇我都将以指针为主线，结合在实际编程中遇到的问题，来详细谈谈关于指针的几个重要方面。
指针类型的本质分析
1、指针的本质
指针的本质：一种复合的数据类型。下面我将以下面几个作为例子进行展开分析：
a)、int *p;
b)、int **p;
c)、int (*parValue)[3];
d)、int (*pFun)();
分析：
所谓的数据类型就是具有某种数据特征的东东，比如数据类型char，它的数据特征就是它所占据的内存为1个字节, 指针也很类似，指针所指向的值也占据着内存中的一块地址，地址的长度与指针的类型有关，比如对于char型指针，这个指针占据的内存就是1个字节，因此指针也是一种数据类型，但我们知道指针本身也占据了一个内存空间地址，地址的长度和机器的字长有关，比如在32位机器中，这个长度就是4个字节，因此指针本身也同样是一种数据类型，因此，我们说，指针其实是一种复合的数据类型，
好了，现在我们可以分析上面的几个例子了。
假设有如下定义：
int nValue;
那么，nValue的类型就是int，也就是把nValue这个具体变量去掉后剩余的部分，因此，上面的4个声明可以类比进行分析：
a)、int *
*代表变量（指针本身）的值是一个地址，int代表这个地址里面存放的是一个整数，这两个结合起来，int *定义了一个指向整数的指针，类推如下:
b)、int **
指向一个指向整数的指针的指针。
c)、int (*)[3]
指向一个拥有三个整数的数组的指针。
d)、int (*)()
指向一个函数的指针，这个函数参数为空，返回值为整数。
分析结束，从上面可以看出，指针包括两个方面，一个是它本身的值，是一个内存中的地址；另一个是指针所指向的物，是这个地址中所存放着具有各种各样意义的数据。
2、对指针本身值的分析
下面例子考察指针本身的值（环境为32位的计算机）：
void *p = malloc( 100 );
请计算sizeof ( p ) = ?
char str[] = “Hello” ;
char *p = str ;
请计算sizeof ( p ) = ?
void Func ( char str[100])
{
请计算 sizeof( str ) = ? //注意，此时，str已经退化为一个指针，详情见
//下一篇指针与数组
}
分析：上面的例子，答案都是4，因为从上面的讨论可以知道，指针本身的值对应着内存中的一个地址，它的size只与机器的字长有关（即它是由系统的内存模型决定的），在32位机器中，这个长度是4个字节。
3、对指针所指向物的分析
现在再对指针这个复合类型的第二部分，指针所指向物的意义进行分析。
上面我们已经得到了指针本身的类型，那么将指针本身的类型去掉 “*”号就可得到指针所指向物的类型，分别如下：
a)、int
所指向物是一个整数。
b)、int*
所指向物是一个指向整数的指针。
c)、int ()[3]
()为空，可以去掉，变为int [3]，所指向物是一个拥有三个整数的数组。
d)、int ()()
第一个()为空，可以去掉，变为int (),所指向物是一个函数，这个函数的参数为空，返回值为整数。
4、附加分析
另外，关于指针本身大小的问题，在C++中与C有所不同，这里我也顺带谈一下。
在C++中，对于指向对象成员的指针，它的大小不一定是4个字节，这主要是因为在引入多重虚拟继承以及虚拟函数的时候，有些附加的信息也需要通过这个指针进行传递，因此指向对象成员的指针会增大，不论是指向成员数据，还是成员函数都是如此，具体与编译器的实现有关，你可以编写个很小的C++程序去验证一下。另外，对一个类的静态成员（static member，可以是静态成员变量或者静态成员函数）来说，指向它的指针只是普通的函数指针，而不是一个指向类成员的指针，所以它的大小不会增加，仍旧是4个字节。
指针运算符&和*
“&和*”，它们是一对相反的操作，’&’取得一个物的地址（也就是指针本身），’*’得到一个地址里放的物（指针所指向的物）。这个东西可以是值（对象）、函数、数组、类成员（class member）等等。
参照上面的分析我们可以很好地理解&与*。
使用指针的好处？
关于指针的本质和基本的运算符我们讨论过了，在这里，我想再笼总地谈一谈使用指针的必要性和好处，为我们今后的使用和对后面篇章的理解做好铺垫。简而言之，指针有以下好处：
1)、方便使用动态分配的数组。
这个解释我放在本系列第六篇中进行讲解。
2)、对于相同类型（甚至是相似类型）的多个变量进行通用访问。
就是用一个指针变量不断在多个变量之间指来指去，从而使得非常应用起来非常灵活，不过，这招也比较危险，需要小心使用：因为出现错误的指针是编程中非常忌讳的事情。
3)、变相改变一个函数的值传递特性。
说白了，就是指针的传地址作用，将一个变量的地址作为参数传给函数，这样函数就可以修改那个变量了。
4)、节省函数调用代价。
我们可以将参数，尤其是大个的参数（例如结构，对象等），将他们地址作为参数传给函数，这样可以省去编译器为它们制作副本所带来的空间和时间上的开销。
5)、动态扩展数据结构。
因为指针可以动态地使用malloc/new生成堆上的内存，所以在需要动态扩展数据结构的时候，非常有用；比如对于树、链表、Hash表等，这几乎是必不可少的特性。
6)、与目前计算机的内存模型相对应，可按照内存地址进行直接存取，这使得C非常适合于一些较底层的应用。
这也是C/C++指针一个强大的优点，我会在后面讲述C语言的底层操作时，较详细地介绍这个优点的应用。
7)、遍历数组。
据个例子来说吧，当你需要对字符串数组进行操作时，想一想，你当然要用字符串指针在字符串上扫来扫去。
…实在太多了，你可以慢慢来补充^_^。
指针本身的相关问题
1、问题：空指针的定义
曾经看过有的.h文件将NULL定义为0L，为什么？
答案与分析：
这是一个关于空指针宏定义的问题。指针在C语言中是经常使用的，有时需要将一个指针置为空指针，例如在指针变量初始化的时候。
C语言中的空指针和Pascal或者Lisp语言中的NIL具有相同的地位。那如何定义空指针呢？下面的语句是正确的：
char *p1 = 0;
int *p2;
if (p != 0)
{
...
}
p2 = 0;
也就是说，在指针变量的初始化、赋值、比较操作中，0会被编译器理解为要将指针置为空指针。至于空指针的内部表示是否是0，则随不同的机器类型而定，不过通常都是0。但是在另外一些场合下，例如函数的参数原型是指针类型，函数调用时如果将0作为参数传入，编译器则不能将其理解为空指针。此时需要明确的类型转换，例如：
void func (char *p);
func ((char *)0);
一般情况下，0是可以放在代码中和指针关联使用的，但是有些程序员（数量还不少呦！也许就包括你在内）不喜欢0的直白，认为其不能表示作为指针的特殊含义，于是要定义一个宏NULL，来明确表示空指针常量。这也是对的，人家C语言标准就明确说：“ NULL应该被定义为与实现相关的空指针常量”。但是将NULL定义成什么样的值呢？我想你一定见过好几种定义NULL的方法：
#define NULL 0
#define NULL (char *)0
#define NULL (void *)0
在我们使用的绝大多数计算系统上，例如PC，上述定义是能够工作的。然而，世界上还有很多其它种类的计算机，其CPU也不是Intel的。在某些系统上，指针和整数的大小和内部表示并不一致，甚至不同类型的指针的大小都不一致。为了避免这种可移植性问题，0L是一种最为安全的、最妥帖的定义方式。0L的含义是： “值为0的整数常量表达式”。这与C语言给出的空指针定义完全一致。因此，建议采用0L作为空指针常量NULL的值。
其实 NULL定义值，和操作系统的的平台有关， 将一个指针定义为 NULL， 其用意是为了保护操作系统，因为通过指针可以访问任何一块地址， 但是，有些数据是不许一般用户访问的，比如操作系统的核心数据。当我们通过一个空(NULL)的指针去方位数据时，系统会提示非法， 那么系统又是如何知道的呢？？
以windows2000系统为例， 该系统规定系统中每个进程的起始地址（0x00000000）开始的某个地址范围内是存放系统数据的，用户进程无法访问， 所以当用户用空指针（0）访问时，其实访问的就是0x00000000地址的系统数据，由于该地址数据是受系统保护的，所以系统会提示错误(指针访问非法)。
这也就是说NULL值不一定要定义成0，起始只要定义在系统的保护范围的地址空间内，比如定义成(0x00000001, 0x00000002)都会起到相同的作用，但是为了考虑到移植性，普遍定义为0 。
2、问题：与指针相关的编程规则&规则分析
指针既然这么重要，而且容易出错，那么有没有方法可以很好地减少这些指针相关问题的出现呢？
答案与分析：
减少出错的根本是彻底理解指针。
在方法上，遵循一定的编码规则可能是最立竿见影的方法了，下面我来阐述一下与指针相关的编程规则：
1) 未使用的指针初始化为NULL 。
2) 在给指针分配空间前、分配后均应作判断。
3) 指针所指向的内容删除后也要清除指针本身。
要牢记指针是一个复合的数据结构这个本质，所以我们不论初始化和清除都要同时兼顾指针本身（上述规则1，3）和指针所指向的内容（上述规则2，3）这两个方面。
遵循这些规则可以有效地减少指针出错，我们来看下面的例子：
void Test(void)
{
char *str = (char *) malloc(100);
strcpy(str, “hello”);
free(str); //str成为野指针
if(str != NULL)
{
strcpy(str, “world”);
printf(str);
}
}
请问运行Test函数会有什么样的结果？
答：
篡改动态内存区的内容，后果难以预料，非常危险。因为free(str);之后，str成为野指针，if(str != NULL)语句不起作用。
如果我们牢记规则3，在free(str)后增加语句：
str = NULL;
那么，就可以防止这样的错误发生。
C语言程序设计基础之预处理
概述
在前面各章中，已多次使用过以“#”号开头的预处理命令。如包含命令# include，宏定义命令# define等。在源程序中这些命令都放在函数之外， 而且一般都放在源文件的前面，它们称为预处理部分。
所谓预处理是指在进行编译的第一遍扫描(词法扫描和语法分析)之前所作的工作。预处理是C语言的一个重要功能， 它由预处理程序负责完成。当对一个源文件进行编译时， 系统将自动引用预处理程序对源程序中的预处理部分作处理，处理完毕自动进入对源程序的编译。
C语言提供了多种预处理功能，如宏定义、文件包含、 条件编译等。合理地使用预处理功能编写的程序便于阅读、修改、移植和调试，也有利于模块化程序设计。本章介绍常用的几种预处理功能。
宏定义
在C语言源程序中允许用一个标识符来表示一个字符串， 称为“宏”。被定义为“宏”的标识符称为“宏名”。在编译预处理时，对程序中所有出现的“宏名”，都用宏定义中的字符串去代换，这称为“宏代换”或“宏展开”。
宏定义是由源程序中的宏定义命令完成的。 宏代换是由预处理程序自动完成的。在C语言中，“宏”分为有参数和无参数两种。 下面分别讨论这两种“宏”的定义和调用。
无参宏定义
无参宏的宏名后不带参数。其定义的一般形式为： #define 标识符 字符串 其中的“#”表示这是一条预处理命令。凡是以“#”开头的均为预处理命令。“define”为宏定义命令。 “标识符”为所定义的宏名。“字符串”可以是常数、表达式、格式串等。在前面介绍过的符号常量的定义就是一种无参宏定义。此外，常对程序中反复使用的表达式进行宏定义。例如： # define M (y*y+3*y) 定义M表达式(y*y+3*y)。在编写源程序时，所有的(y*y+3*y)都可由M代替，而对源程序作编译时，将先由预处理程序进行宏代换，即用(y*y+3*y)表达式去置换所有的宏名M，然后再进行编译。
#define M (y*y+3*y)
main(){
int s,y;
printf("input a number: ");
scanf("%d",&y);
s=3*M+4*M+5*M;
printf("s=%d\n",s);
}
上例程序中首先进行宏定义，定义M表达式(y*y+3*y),在s= 3*M+4*M+5* M中作了宏调用。在预处理时经宏展开后该语句变为：s=3*(y*y+3*y)+4(y*y+3*y)+5(y*y+3*y);但要注意的是，在宏定义中表达式(y*y+3*y)两边的括号不能少。否则会发生错误。
当作以下定义后： #difine M y*y+3*y在宏展开时将得到下述语句： s=3*y*y+3*y+4*y*y+3*y+5*y*y+3*y；这相当于； 3y2+3y+4y2+3y+5y2+3y；显然与原题意要求不符。计算结果当然是错误的。 因此在作宏定义时必须十分注意。应保证在宏代换之后不发生错误。对于宏定义还要说明以下几点：
1. 宏定义是用宏名来表示一个字符串，在宏展开时又以该字符串取代宏名，这只是一种简单的代换，字符串中可以含任何字符，可以是常数，也可以是表达式，预处理程序对它不作任何检查。如有错误，只能在编译已被宏展开后的源程序时发现。
2. 宏定义不是说明或语句，在行末不必加分号，如加上分号则连分号也一起置换。
3. 宏定义必须写在函数之外，其作用域为宏定义命令起到源程序结束。如要终止其作用域可使用# undef命令，例如：
# define PI 3.14159
main()
{
……
}
# undef PIPI的作用域
f1()
....表示PI只在main函数中有效，在f1中无效。
4. 宏名在源程序中若用引号括起来，则预处理程序不对其作宏代换。
#define OK 100
main()
{
printf("OK");
printf("\n");
}
上例中定义宏名OK表示100，但在printf语句中OK被引号括起来，因此不作宏代换。程序的运行结果为：OK这表示把“OK”当字符串处理。
5. 宏定义允许嵌套，在宏定义的字符串中可以使用已经定义的宏名。在宏展开时由预处理程序层层代换。例如：
#define PI 3.1415926
#define S PI*y*y 对语句： printf("%f",s);
在宏代换后变为： printf("%f",3.1415926*y*y);
6. 习惯上宏名用大写字母表示，以便于与变量区别。但也允许用小写字母。
7. 可用宏定义表示数据类型，使书写方便。例如： #define STU struct stu在程序中可用STU作变量说明：
STU body[5],*p;
#define INTEGER int
在程序中即可用INTEGER作整型变量说明： INTEGER a,b; 应注意用宏定义表示数据类型和用typedef定义数据说明符的区别。宏定义只是简单的字符串代换，是在预处理完成的，而typedef是在编译时处理的，它不是作简单的代换，而是对类型说明符重新命名。被命名的标识符具有类型定义说明的功能。请看下面的例子： #define PIN1 int* typedef (int*) PIN2;从形式上看这两者相似， 但在实际使用中却不相同。下面用PIN1，PIN2说明变量时就可以看出它们的区别： PIN1 a,b;在宏代换后变成 int *a,b;表示a是指向整型的指针变量，而b是整型变量。然而：PIN2 a,b;表示a,b都是指向整型的指针变量。因为PIN2是一个类型说明符。由这个例子可见，宏定义虽然也可表示数据类型， 但毕竟是作字符代换。在使用时要分外小心，以避出错。
8. 对“输出格式”作宏定义，可以减少书写麻烦。例9.3 中就采用了这种方法。
#define P printf
#define D "%d\n"
#define F "%f\n"
main(){
int a=5, c=8, e=11;
float b=3.8, d=9.7, f=21.08;
P(D F,a,b);
P(D F,c,d);
P(D F,e,f);
}
带参宏定义
C语言允许宏带有参数。在宏定义中的参数称为形式参数，在宏调用中的参数称为实际参数。对带参数的宏，在调用中，不仅要宏展开， 而且要用实参去代换形参。
带参宏定义的一般形式为： #define 宏名(形参表) 字符串 在字符串中含有各个形参。带参宏调用的一般形式为： 宏名(实参表)；
例如：
#define M(y) y*y+3*y
:k=M(5);
: 在宏调用时，用实参5去代替形参y， 经预处理宏展开后的语句
为： k=5*5+3*5
#define MAX(a,b) (a>b)?a:b
main(){
int x,y,max;
printf("input two numbers: ");
scanf("%d%d",&x,&y);
max=MAX(x,y);
printf("max=%d\n",max);
}
上例程序的第一行进行带参宏定义，用宏名MAX表示条件表达式(a>b)?a:b，形参a,b均出现在条件表达式中。程序第七行max=MAX(x,
y)为宏调用，实参x,y，将代换形参a,b。宏展开后该语句为： max=(x>y)?x:y;用于计算x,y中的大数。对于带参的宏定义有以下问题需要说明：
1. 带参宏定义中，宏名和形参表之间不能有空格出现。
例如把： #define MAX(a,b) (a>b)?a:b写为： #define MAX (a,b) (a>b)?a:b 将被认为是无参宏定义，宏名MAX代表字符串 (a,b)(a>b)?a:b。
宏展开时，宏调用语句： max=MAX(x,y);将变为： max=(a,b)(a>b)?a:b(x,y);这显然是错误的。
2. 在带参宏定义中，形式参数不分配内存单元，因此不必作类型定义。而宏调用中的实参有具体的值。要用它们去代换形参，因此必须作类型说明。这是与函数中的情况不同的。在函数中，形参和实参是两个不同的量，各有自己的作用域，调用时要把实参值赋予形参，进行“值传递”。而在带参宏中，只是符号代换，不存在值传递的问题。
3. 在宏定义中的形参是标识符，而宏调用中的实参可以是表达式。
#define SQ(y) (y)*(y)
main(){
int a,sq;
printf("input a number: ");
scanf("%d",&a);
sq=SQ(a+1);
printf("sq=%d\n",sq);
}
上例中第一行为宏定义，形参为y。程序第七行宏调用中实参为a+1，是一个表达式，在宏展开时，用a+1代换y，再用(y)*(y) 代换SQ，得到如下语句： sq=(a+1)*(a+1); 这与函数的调用是不同的，函数调用时要把实参表达式的值求出来再赋予形参。 而宏代换中对实参表达式不作计算直接地照原样代换。
4. 在宏定义中，字符串内的形参通常要用括号括起来以避免出错。 在上例中的宏定义中(y)*(y)表达式的y都用括号括起来，因此结果是正确的。如果去掉括号，把程序改为以下形式：
#define SQ(y) y*y
main(){
int a,sq;
printf("input a number: ");
scanf("%d",&a);
sq=SQ(a+1);
printf("sq=%d\n",sq);
}
运行结果为：input a number:3
sq=7 同样输入3，但结果却是不一样的。问题在哪里呢? 这是由于代换只作符号代换而不作其它处理而造成的。 宏代换后将得到以下语句： sq=a+1*a+1; 由于a为3故sq的值为7。这显然与题意相违，因此参数两边的括号是不能少的。即使在参数两边加括号还是不够的，请看下面程序：
#define SQ(y) (y)*(y)
main(){
int a,sq;
printf("input a number: ");
scanf("%d",&a);
sq=160/SQ(a+1);
printf("sq=%d\n",sq);
}
本程序与前例相比，只把宏调用语句改为： sq=160/SQ(a+1); 运行本程序如输入值仍为3时，希望结果为10。但实际运行的结果如下：input a number:3 sq=160为什么会得这样的结果呢?分析宏调用语句，在宏代换之后变为： sq=160/(a+1)*(a+1);a为3时，由于“/”和“*”运算符优先级和结合性相同， 则先作160/(3+1)得40，再作40*(3+1)最后得160。为了得到正确答案应在宏定义中的整个字符串外加括号， 程序修改如下
#define SQ(y) ((y)*(y))
main(){
int a,sq;
printf("input a number: ");
scanf("%d",&a);
sq=160/SQ(a+1);
printf("sq=%d\n",sq);
}
以上讨论说明，对于宏定义不仅应在参数两侧加括号，也应在整个字符串外加括号。
5. 带参的宏和带参函数很相似，但有本质上的不同，除上面已谈到的各点外，把同一表达式用函数处理与用宏处理两者的结果有可能是不同的。
main(){
int i=1;
while(i<=5)
printf("%d\n",SQ(i++));
}
SQ(int y)
{
return((y)*(y));
}#define SQ(y) ((y)*(y))
main(){
int i=1;
while(i<=5)
printf("%d\n",SQ(i++));
}
在上例中函数名为SQ，形参为Y，函数体表达式为((y)*(y))。在例9.6中宏名为SQ，形参也为y，字符串表达式为(y)*(y))。 两例是相同的。例9.6的函数调用为SQ(i++)，例9.7的宏调用为SQ(i++)，实参也是相同的。从输出结果来看，却大不相同。分析如下：在例9.6中，函数调用是把实参i值传给形参y后自增1。 然后输出函数值。因而要循环5次。输出1～5的平方值。而在例9.7中宏调用时，只作代换。SQ(i++)被代换为((i++)*(i++))。在第一次循环时，由于i等于1，其计算过程为：表达式中前一个i初值为1，然后i自增1变为2，因此表达式中第2个i初值为2，两相乘的结果也为2，然后i值再自增1，得3。在第二次循环时，i值已有初值为3，因此表达式中前一个i为3，后一个i为4， 乘积为12，然后i再自增1变为5。进入第三次循环，由于i 值已为5，所以这将是最后一次循环。计算表达式的值为5*6等于30。i值再自增1变为6，不再满足循环条件，停止循环。从以上分析可以看出函数调用和宏调用二者在形式上相似，在本质上是完全不同的。
6. 宏定义也可用来定义多个语句，在宏调用时，把这些语句又代换到源程序内。看下面的例子。
#define SSSV(s1,s2,s3,v) s1=l*w;s2=l*h;s3=w*h;v=w*l*h;
main(){
int l=3,w=4,h=5,sa,sb,sc,vv;
SSSV(sa,sb,sc,vv);
printf("sa=%d\nsb=%d\nsc=%d\nvv=%d\n",sa,sb,sc,vv);
}
程序第一行为宏定义，用宏名SSSV表示4个赋值语句，4 个形参分别为4个赋值符左部的变量。在宏调用时，把4 个语句展开并用实参代替形参。使计算结果送入实参之中。
文件包含
文件包含是C预处理程序的另一个重要功能。文件包含命令行的一般形式为： #include"文件名" 在前面我们已多次用此命令包含过库函数的头文件。例如：
#include"stdio.h"
#include"math.h"
文件包含命令的功能是把指定的文件插入该命令行位置取代该命令行，从而把指定的文件和当前的源程序文件连成一个源文件。在程序设计中，文件包含是很有用的。 一个大的程序可以分为多个模块，由多个程序员分别编程。 有些公用的符号常量或宏定义等可单独组成一个文件，在其它文件的开头用包含命令包含该文件即可使用。这样，可避免在每个文件开头都去书写那些公用量， 从而节省时间，并减少出错。
对文件包含命令还要说明以下几点：
1. 包含命令中的文件名可以用双引号括起来，也可以用尖括号括起来。例如以下写法都是允许的： #include"stdio.h" #include<math.h> 但是这两种形式是有区别的：使用尖括号表示在包含文件目录中去查找(包含目录是由用户在设置环境时设置的)， 而不在源文件目录去查找； 使用双引号则表示首先在当前的源文件目录中查找，若未找到才到包含目录中去查找。 用户编程时可根据自己文件所在的目录来选择某一种命令形式。
2. 一个include命令只能指定一个被包含文件，若有多个文件要包含，则需用多个include命令。3. 文件包含允许嵌套，即在一个被包含的文件中又可以包含另一个文件。
条件编译
预处理程序提供了条件编译的功能。 可以按不同的条件去编译不同的程序部分，因而产生不同的目标代码文件。 这对于程序的移植和调试是很有用的。 条件编译有三种形式，下面分别介绍：
1. 第一种形式：
#ifdef 标识符
程序段1
#else
程序段2
#endif
它的功能是，如果标识符已被 #define命令定义过则对程序段1进行编译；否则对程序段2进行编译。如果没有程序段2(它为空)，本格式中的#else可以没有， 即可以写为：
#ifdef 标识符
程序段 #endif
#define NUM ok
main(){
struct stu
{
int num;
char *name;
char sex;
float score;
} *ps;
ps=(struct stu*)malloc(sizeof(struct stu));
ps->num=102;
ps->name="Zhang ping";
ps->sex='M';
ps->score=62.5;
#ifdef NUM
printf("Number=%d\nScore=%f\n",ps->num,ps->score);
#else
printf("Name=%s\nSex=%c\n",ps->name,ps->sex);
#endif
free(ps);
}
由于在程序的第16行插入了条件编译预处理命令， 因此要根据NUM是否被定义过来决定编译那一个printf语句。而在程序的第一行已对NUM作过宏定义，因此应对第一个printf语句作编译故运行结果是输出了学号和成绩。在程序的第一行宏定义中，定义NUM表示字符串OK，其实也可以为任何字符串，甚至不给出任何字符串，写为： #define NUM 也具有同样的意义。只有取消程序的第一行才会去编译第二个printf语句。读者可上机试作。
2. 第二种形式：
#ifndef 标识符
程序段1
#else
程序段2
#endif
与第一种形式的区别是将“ifdef”改为“ifndef”。它的功能是，如果标识符未被#define命令定义过则对程序段1进行编译， 否则对程序段2进行编译。这与第一种形式的功能正相反。
3. 第三种形式：
#if 常量表达式
程序段1
#else
程序段2
#endif
它的功能是，如常量表达式的值为真(非0)，则对程序段1 进行编译，否则对程序段2进行编译。因此可以使程序在不同条件下，完成不同的功能
#define R 1
main(){
float c,r,s;
printf ("input a number: ");
scanf("%f",&c);
#if R
r=3.14159*c*c;
printf("area of round is: %f\n",r);
#else
s=c*c;
printf("area of square is: %f\n",s);
#endif
}
本例中采用了第三种形式的条件编译。在程序第一行宏定义中，定义R为1，因此在条件编译时，常量表达式的值为真， 故计算并输出圆面积。上面介绍的条件编译当然也可以用条件语句来实现。但是用条件语句将会对整个源程序进行编译，生成的目标代码程序很长，而采用条件编译，则根据条件只编译其中的程序段1或程序段2， 生成的目标程序较短。如果条件选择的程序段很长， 采用条件编译的方法是十分必要的。
C语言嵌入式系统编程修炼之背景篇
不同于一般形式的软件编程，嵌入式系统编程建立在特定的硬件平台上，势必要求其编程语言具备较强的硬件直接操作能力。无疑，汇编语言具备这样的特质。但是，归因于汇编语言开发过程的复杂性，它并不是嵌入式系统开发的一般选择。而与之相比，C语言--一种"高级的低级"语言，则成为嵌入式系统开发的最佳选择。笔者在嵌入式系统项目的开发过程中，一次又一次感受到C语言的精妙，沉醉于C语言给嵌入式开发带来的便利。
图1给出了本文的讨论所基于的硬件平台，实际上，这也是大多数嵌入式系统的硬件平台。它包括两部分：
（1） 以通用处理器为中心的协议处理模块，用于网络控制协议的处理；
（2） 以数字信号处理器（DSP）为中心的信号处理模块，用于调制、解调和数/模信号转换。
本文的讨论主要围绕以通用处理器为中心的协议处理模块进行，因为它更多地牵涉到具体的C语言编程技巧。而DSP编程则重点关注具体的数字信号处理算法，主要涉及通信领域的知识，不是本文的讨论重点。
着眼于讨论普遍的嵌入式系统C编程技巧，系统的协议处理模块没有选择特别的CPU，而是选择了众所周知的CPU芯片--80186，每一位学习过《微机原理》的读者都应该对此芯片有一个基本的认识，且对其指令集比较熟悉。80186的字长是16位，可以寻址到的内存空间为1MB，只有实地址模式。C语言编译生成的指针为32位（双字），高16位为段地址，低16位为段内编译，一段最多64KB。
协议处理模块中的FLASH和RAM几乎是每个嵌入式系统的必备设备，前者用于存储程序，后者则是程序运行时指令及数据的存放位置。系统所选择的FLASH和RAM的位宽都为16位，与CPU一致。
实时钟芯片可以为系统定时，给出当前的年、月、日及具体时间（小时、分、秒及毫秒），可以设定其经过一段时间即向CPU提出中断或设定报警时间到来时向CPU提出中断（类似闹钟功能）。
NVRAM（非易失去性RAM）具有掉电不丢失数据的特性，可以用于保存系统的设置信息，譬如网络协议参数等。在系统掉电或重新启动后，仍然可以读取先前的设置信息。其位宽为8位，比CPU字长小。文章特意选择一个与CPU字长不一致的存储芯片，为后文中一节的讨论创造条件。
UART则完成CPU并行数据传输与RS-232串行数据传输的转换，它可以在接收到[1~MAX_BUFFER]字节后向CPU提出中断，MAX_BUFFER为UART芯片存储接收到字节的最大缓冲区。
键盘控制器和显示控制器则完成系统人机界面的控制。
以上提供的是一个较完备的嵌入式系统硬件架构，实际的系统可能包含更少的外设。之所以选择一个完备的系统，是为了后文更全面的讨论嵌入式系统C语言编程技巧的方方面面，所有设备都会成为后文的分析目标。
嵌入式系统需要良好的软件开发环境的支持，由于嵌入式系统的目标机资源受限，不可能在其上建立庞大、复杂的开发环境，因而其开发环境和目标运行环境相互分离。因此，嵌入式应用软件的开发方式一般是，在宿主机(Host)上建立开发环境，进行应用程序编码和交叉编译，然后宿主机同目标机(Target)建立连接，将应用程序下载到目标机上进行交叉调试，经过调试和优化，最后将应用程序固化到目标机中实际运行。
CAD-UL是适用于x86处理器的嵌入式应用软件开发环境，它运行在Windows操作系统之上，可生成x86处理器的目标代码并通过PC机的COM口（RS-232串口）或以太网口下载到目标机上运行，如图2。其驻留于目标机FLASH存储器中的monitor程序可以监控宿主机Windows调试平台上的用户调试指令，获取CPU寄存器的值及目标机存储空间、I/O空间的内容。
后续章节将从软件架构、内存操作、屏幕操作、键盘操作、性能优化等多方面阐述C语言嵌入式系统的编程技巧。软件架构是一个宏观概念，与具体硬件的联系不大；内存操作主要涉及系统中的FLASH、RAM和NVRAM芯片；屏幕操作则涉及显示控制器和实时钟；键盘操作主要涉及键盘控制器；性能优化则给出一些具体的减小程序时间、空间消耗的技巧。
在我们的修炼旅途中将经过25个关口，这些关口主分为两类，一类是技巧型，有很强的适用性；一类则是常识型，在理论上有些意义。
C语言嵌入式系统编程修炼之键盘操作
处理功能键
功能键的问题在于，用户界面并非固定的，用户功能键的选择将使屏幕画面处于不同的显示状态下。例如，主画面如图1：
当用户在设置XX上按下Enter键之后，画面就切换到了设置XX的界面，如图2：
程序如何判断用户处于哪一画面，并在该画面的程序状态下调用对应的功能键处理函数，而且保证良好的结构，是一个值得思考的问题。
让我们来看看WIN32编程中用到的"窗口"概念，当消息（message）被发送给不同窗口的时候，该窗口的消息处理函数（是一个callback函数）最终被调用，而在该窗口的消息处理函数中，又根据消息的类型调用了该窗口中的对应处理函数。通过这种方式，WIN32有效的组织了不同的窗口，并处理不同窗口情况下的消息。
我们从中学习到的就是：
（1）将不同的画面类比为WIN32中不同的窗口，将窗口中的各种元素（菜单、按钮等）包含在窗口之中；
（2）给各个画面提供一个功能键"消息"处理函数，该函数接收按键信息为参数；
（3）在各画面的功能键"消息"处理函数中，判断按键类型和当前焦点元素，并调用对应元素的按键处理函数。
struct windows
{
BYTE currentFocus;
ELEMENT element[ELEMENT_NUM];
void (*messageFun) (BYTE keyValue);
…
};
void messageFunction(BYTE keyValue)
{
BYTE i = 0;
while ( (element [i].ID!= currentFocus)&& (i < ELEMENT_NUM) )
{
i++;
}
if(i < ELEMENT_NUM)
{
switch(keyValue)
{
case OK:
element[i].OnOk();
break;
…
}
}
}
在窗口的消息处理函数中调用相应元素按键函数的过程类似于"消息映射"，这是我们从WIN32编程中学习到的。编程到了一个境界，很多东西都是相通的了。其它地方的思想可以拿过来为我所用，是为编程中的"拿来主义"。
在这个例子中，如果我们还想玩得更大一点，我们可以借鉴MFC中处理MESSAGE_MAP的方法，我们也可以学习MFC定义几个精妙的宏来实现"消息映射"。
处理数字键
用户输入数字时是一位一位输入的，每一位的输入都对应着屏幕上的一个显示位置（x坐标，y坐标）。此外，程序还需要记录该位置输入的值，所以有效组织用户数字输入的最佳方式是定义一个结构体，将坐标和数值捆绑在一起：
typedef struct tagInputNum
{
BYTE byNum;
BYTE xPos;
BYTE yPos;
}InputNum, *LPInputNum;
那么接收用户输入就可以定义一个结构体数组，用数组中的各位组成一个完整的数字：
InputNum inputElement[NUM_LENGTH];
extern void onNumKey(BYTE num)
{
if(num==0|| num==1)
{
DrawText(inputElement[currentElementInputPlace
inputElement[currentElementInputPlace
moveToRight();
}
}
将数字每一位输入的坐标和输入值捆绑后，在数字键处理函数中就可以较有结构的组织程序，使程序显得很紧凑。
整理用户输入
继续第2节的例子，在第2节的onNumKey函数中，只是获取了数字的每一位，因而我们需要将其转化为有效数据，譬如要转化为有效的XXX数据，其方法是：
* 从2进制数据位转化为有效数据：XXX */
void convertToXXX()
{
BYTE i;
XXX = 0;
for (i = 0; i < NUM_LENGTH; i++)
{
XXX += inputElement[i].byNum*power(2, NUM_LENGTH - i - 1);
}
}
反之，我们也可能需要在屏幕上显示那些有效的数据位，因为我们也需要能够反向转化
* 从有效数据转化为2进制数据位：XXX */
void convertFromXXX()
{
BYTE i;
XXX = 0;
for (i = 0; i < NUM_LENGTH; i++)
{
inputElement[i].byNum = XXX / power(2, NUM_LENGTH - i - 1) % 2;
}
}
当然在上面的例子中，因为数据是2进制的，用power函数不是很好的选择，直接用"<< >>"移位操作效率更高，我们仅是为了说明问题的方便。试想，如果用户输入是十进制的，power函数或许是唯一的选择了。
总结
本篇给出了键盘操作所涉及的各个方面：功能键处理、数字键处理及用户输入整理，基本上提供了一个全套的按键处理方案。对于功能键处理方法，将LCD屏幕与Windows窗口进行类比，提出了较新颖地解决屏幕、键盘繁杂交互问题的方案。
计算机学的许多知识都具有相通性，因而，不断追赶时髦技术而忽略基本功的做法是徒劳无意的。我们最多需要"精通"三种语言（精通，一个在如今的求职简历里泛滥成灾的词语），最佳拍档是汇编、C、C++（或JAVA），很显然，如果你"精通"了这三种语言，其它语言你应该是可以很快"熟悉"的，否则你就没有"精通"它们
C语言嵌入式系统编程修炼之内存操作
数据指针：
在嵌入式系统的编写中，常常要求在特定的内存单元读写内容，汇编有对应的MOV指令，而除C/C++以外的其他编程语言基本没有直接访问绝对地址的能力。在嵌入式系统的实际调试中，多借助C语言指针所具有的对绝对地址单元内容的读写能力。以指针直接操作内存多发生如下几种情况：
（1） 某I/O芯片被定位在CPU的存储空间而非I/O空间，而且寄存器对应于某特定地址。
（2） 两个CPU之间以双端口RAM通信，CPU需要在双端口RAM的特定单元（称为mail box）书写内容以在对方CPU产生中断；
（3） 读取在ROM或FLASH的特定单元所烧录的汉字和英文字模。
譬如：
unsigned char *p = (unsigned char *)0xF000FF00;
*p=11;
以上程序的意义为在绝对地址0xF0000+0xFF00(80186使用16位段地址和16位偏移地址)写入11。
在使用绝对地址指针时，要注意指针自增自减操作的结果取决于指针指向的数据类别。上例中p++后的结果是p= 0xF000FF01，若p指向int，即：
int *p = (int *)0xF000FF00;
p++(或++p)的结果等同于：p = p+sizeof(int)，而p-(或-p)的结果是p = p-sizeof(int)。
同理，若执行：
long int *p = (long int *)0xF000FF00;
则p++(或++p)的结果等同于：p = p+sizeof(long int) ，而p-(或-p)的结果是p = p-sizeof(long int)。
记住：CPU以字节为单位编址，而C语言指针以指向的数据类型长度作自增和自减。理解这一点对于以指针直接操作内存是相当重要的。
函数指针
首先要理解以下三个问题：
（1）C语言中函数名直接对应于函数生成的指令代码在内存中的地址，因此函数名可以直接赋给指向函数的指针；
（2）调用函数实际上等同于"调转指令＋参数传递处理＋回归位置入栈"，本质上最核心的操作是将函数生成的目标代码的首地址赋给CPU的PC寄存器；
（3）因为函数调用的本质是跳转到某一个地址单元的code去执行，所以可以"调用"一个根本就不存在的函数实体，晕？请往下看：
请拿出你可以获得的任何一本大学《微型计算机原理》教材，书中讲到，186 CPU启动后跳转至绝对地址0xFFFF0（对应C语言指针是0xF000FFF0，0xF000为段地址，0xFFF0为段内偏移）执行，请看下面的代码：
typedef void(*lpFunction) ( );
lpFunction lpReset = (lpFunction)0xF000FFF0;
lpReset();
在以上的程序中，我们根本没有看到任何一个函数实体，但是我们却执行了这样的函数调用：lpReset()，它实际上起到了"软重启"的作用，跳转到CPU启动后第一条要执行的指令的位置。
记住：函数无它，唯指令集合耳；你可以调用一个没有函数体的函数，本质上只是换一个地址开始执行指令！
数组vs.动态申请
在嵌入式系统中动态内存申请存在比一般系统编程时更严格的要求，这是因为嵌入式系统的内存空间往往是十分有限的，不经意的内存泄露会很快导致系统的崩溃。
所以一定要保证你的malloc和free成对出现，如果你写出这样的一段程序：
char * function(void)
{
char *p;
p = (char *)malloc(…);
if(p==NULL)
…;
…
return p;
}
在某处调用function()，用完function中动态申请的内存后将其free，如下：
char *q = function();
…free(q);
上述代码明显是不合理的，因为违反了malloc和free成对出现的原则，即"谁申请，就由谁释放"原则。不满足这个原则，会导致代码的耦合度增大，因为用户在调用function函数时需要知道其内部细节！
正确的做法是在调用处申请内存，并传入function函数，如下：
char *p=malloc(…);
if(p==NULL)
…;
function(p);
…
free(p);
p=NULL;
而函数function则接收参数p，如下：
void function(char *p)
{
…
}
基本上，动态申请内存方式可以用较大的数组替换。对于编程新手，笔者推荐你尽量采用数组！嵌入式系统可以以博大的胸襟接收瑕疵，而无法"海纳"错误。毕竟，以最笨的方式苦练神功的郭靖胜过机智聪明却范政治错误走反革命道路的杨康。
给出原则：
（1）尽可能的选用数组，数组不能越界访问（真理越过一步就是谬误，数组越过界限就光荣地成全了一个混乱的嵌入式系统）；
（2）如果使用动态申请，则申请后一定要判断是否申请成功了，并且malloc和free应成对出现！
关键字const
const意味着"只读"。区别如下代码的功能非常重要，也是老生长叹，如果你还不知道它们的区别，而且已经在程序界摸爬滚打多年，那只能说这是一个悲哀：
const int a;
int const a;
const int *a; // a是一个指向常整型数的指针
int * const a;// a是一个指向整型数的常指针
int const * a const;// a是一个指向常整型数的常指针（也就是说，指针指向的整型数是不可修改的，同时指针也是不可修改的）
（1） 关键字const的作用是为给读你代码的人传达非常有用的信息。例如，在函数的形参前添加const关键字意味着这个参数在函数体内不会被修改，属于"输入参数"。在有多个形参的时候，函数的调用者可以凭借参数前是否有const关键字，清晰的辨别哪些是输入参数，哪些是可能的输出参数。
（2）合理地使用关键字const可以使编译器很自然地保护那些不希望被改变的参数，防止其被无意的代码修改，这样可以减少bug的出现。
const在C++语言中则包含了更丰富的含义，而在C语言中仅意味着："只能读的普通变量"，可以称其为"不能改变的变量"（这个说法似乎很拗口，但却最准确的表达了C语言中const的本质），在编译阶段需要的常数仍然只能以#define宏定义！故在C语言中如下程序是非法的：
const int SIZE = 10;
char a[SIZE];
关键字volatile
C语言编译器会对用户书写的代码进行优化，譬如如下代码：
int a,b,c;
a = inWord(0x100);
b = a;
a = inWord (0x100);
c = a;
很可能被编译器优化为：
int a,b,c;
a = inWord(0x100);
b = a;
c = a;
但是这样的优化结果可能导致错误，如果I/O空间0x100端口的内容在执行第一次读操作后被其它程序写入新值，则其实第2次读操作读出的内容与第一次不同，b和c的值应该不同。在变量a的定义前加上volatile关键字可以防止编译器的类似优化，正确的做法是：
volatile int a；
volatile变量可能用于如下几种情况：
(1) 并行设备的硬件寄存器（如：状态寄存器，例中的代码属于此类）；
(2) 一个中断服务子程序中会访问到的非自动变量(也就是全局变量)；
(3) 多线程应用中被几个任务共享的变量。
CPU字长与存储器位宽不一致处理
在背景篇中提到，本文特意选择了一个与CPU字长不一致的存储芯片，就是为了进行本节的讨论，解决CPU字长与存储器位宽不一致的情况。80186的字长为16，而NVRAM的位宽为8，在这种情况下，我们需要为NVRAM提供读写字节、字的接口，如下：
typedef unsigned char BYTE;
typedef unsigned int WORD;
extern BYTE ReadByteNVRAM(WORD wOffset)
{
LPBYTE lpAddr = (BYTE*)(NVRAM + wOffset * 2);
return *lpAddr;
}
extern WORD ReadWordNVRAM(WORD wOffset)
{
WORD wTmp = 0;
LPBYTE lpAddr;
lpAddr = (BYTE*)(NVRAM + wOffset * 2);
wTmp += (*lpAddr)*256;
lpAddr = (BYTE*)(NVRAM + (wOffset +1) * 2);
wTmp += *lpAddr;
return wTmp;
}
extern void WriteByteNVRAM(WORD wOffset, BYTE byData)
{
…
}
*参数：wOffset，写入位置相对NVRAM基地址的偏移
* wData，欲写入的字
*/
extern void WriteWordNVRAM(WORD wOffset, WORD wData)
{
…
}
子贡问曰：Why偏移要乘以2?
子曰：请看图1，16位80186与8位NVRAM之间互连只能以地址线A1对其A0,CPU本身的A0与NVRAM不连接。因此，NVRAM的地址只能是偶数地址，故每次以0x10为单位前进！
子贡再问：So why 80186的地址线A0不与NVRAM的A0连接？
子曰：请看《IT论语》之《微机原理篇》，那里面讲述了关于计算机组成的圣人之道。
总结
本篇主要讲述了嵌入式系统C编程中内存操作的相关技巧。掌握并深入理解关于数据指针、函数指针、动态申请内存、const及volatile关键字等的相关知识，是一个优秀的C语言程序设计师的基本要求。当我们已经牢固掌握了上述技巧后，我们就已经学会了C语言的99%，因为C语言最精华的内涵皆在内存操作中体现。
我们之所以在嵌入式系统中使用C语言进行程序设计，99%是因为其强大的内存操作能力！
如果你爱编程，请你爱C语言；
如果你爱C语言，请你爱指针；
如果你爱指针，请你爱指针的指针！
C语言嵌入式系统编程修炼之屏幕操作
汉字处理
现在要解决的问题是，嵌入式系统中经常要使用的并非是完整的汉字库，往往只是需要提供数量有限的汉字供必要的显示功能。例如，一个微波炉的LCD上没有必要提供显示"电子邮件"的功能；一个提供汉字显示功能的空调的LCD上不需要显示一条"短消息"，诸如此类。但是一部手机、小灵通则通常需要包括较完整的汉字库。
如果包括的汉字库较完整，那么，由内码计算出汉字字模在库中的偏移是十分简单的：汉字库是按照区位的顺序排列的，前一个字节为该汉字的区号，后一个字节为该字的位号。每一个区记录94个汉字，位号则为该字在该区中的位置。因此，汉字在汉字库中的具体位置计算公式为：94*(区号-1)+位号-1。减1是因为数组是以0为开始而区号位号是以1为开始的。只需乘上一个汉字字模占用的字节数即可，即：(94*(区号-1)+位号-1)*一个汉字字模占用字节数，以16*16点阵字库为例，计算公式则为：(94*(区号-1)+(位号-1))*32。汉字库中从该位置起的32字节信息记录了该字的字模信息。
对于包含较完整汉字库的系统而言，我们可以以上述规则计算字模的位置。但是如果仅仅是提供少量汉字呢？譬如几十至几百个？最好的做法是：
定义宏：
# define EX_FONT_CHAR(value)
# define EX_FONT_UNICODE_VAL(value) (value),
# define EX_FONT_ANSI_VAL(value) (value),
定义结构体：
typedef struct _wide_unicode_font16x16
{
WORD value;
BYTE data[32];
}Unicode;
#define CHINESE_CHAR_NUM …
字模的存储用数组：
Unicode chinese[CHINESE_CHAR_NUM] =
{
{
EX_FONT_CHAR("业")
EX_FONT_UNICODE_VAL(0x4e1a)
{0x04, 0x40, 0x04, 0x40, 0x04, 0x40, 0x04, 0x44, 0x44, 0x46, 0x24, 0x4c, 0x24, 0x48, 0x14, 0x50, 0x1c, 0x50, 0x14, 0x60, 0x04, 0x40, 0x04, 0x40, 0x04, 0x44, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00}
},
{
EX_FONT_CHAR("中")
EX_FONT_UNICODE_VAL(0x4e2d)
{0x01, 0x00, 0x01, 0x00, 0x21, 0x08, 0x3f, 0xfc, 0x21, 0x08, 0x21, 0x08, 0x21, 0x08, 0x21, 0x08, 0x21, 0x08,
0x3f, 0xf8, 0x21, 0x08, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00}
},
{
EX_FONT_CHAR("云")
EX_FONT_UNICODE_VAL(0x4e91)
{0x00, 0x00, 0x00, 0x30, 0x3f, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xff, 0xfe, 0x03, 0x00, 0x07, 0x00, 0x06, 0x40, 0x0c, 0x20, 0x18, 0x10, 0x31, 0xf8, 0x7f, 0x0c, 0x20, 0x08, 0x00, 0x00}
},
{
EX_FONT_CHAR("件")
EX_FONT_UNICODE_VAL(0x4ef6)
{0x10, 0x40, 0x1a, 0x40, 0x13, 0x40, 0x32, 0x40, 0x23, 0xfc, 0x64, 0x40, 0xa4, 0x40, 0x28, 0x40, 0x2f, 0xfe, 0x20, 0x40, 0x20, 0x40, 0x20, 0x40, 0x20, 0x40, 0x20, 0x40, 0x20, 0x40, 0x20, 0x40}
}
}
要显示特定汉字的时候，只需要从数组中查找内码与要求汉字内码相同的即可获得字模。如果前面的汉字在数组中以内码大小顺序排列，那么可以以二分查找法更高效的查找到汉字的字模。
这是一种很有效的组织小汉字库的方法，它可以保证程序有很好的结构。
系统时间显示
从NVRAM中可以读取系统的时间，系统一般借助NVRAM产生的秒中断每秒读取一次当前时间并在LCD上显示。关于时间的显示，有一个效率问题。因为时间有其特殊性，那就是60秒才有一次分钟的变化，60分钟才有一次小时变化，如果我们每次都将读取的时间在屏幕上完全重新刷新一次，则浪费了大量的系统时间。
一个较好的办法是我们在时间显示函数中以静态变量分别存储小时、分钟、秒，只有在其内容发生变化的时候才更新其显示。
extern void DisplayTime(…)
{
static BYTE byHour,byMinute,bySecond;
BYTE byNewHour, byNewMinute, byNewSecond;
byNewHour = GetSysHour();
byNewMinute = GetSysMinute();
byNewSecond = GetSysSecond();
if(byNewHour!= byHour)
{
…
byHour = byNewHour;
}
if(byNewMinute!= byMinute)
{
…
byMinute = byNewMinute;
}
if(byNewSecond!= bySecond)
{
…
bySecond = byNewSecond;
}
}
这个例子也可以顺便作为C语言中static关键字强大威力的证明。当然，在C++语言里，static具有了更加强大的威力，它使得某些数据和函数脱离"对象"而成为"类"的一部分，正是它的这一特点，成就了软件的无数优秀设计。
动画显示
动画是无所谓有，无所谓无的，静止的画面走的路多了，也就成了动画。随着时间的变更，在屏幕上显示不同的静止画面，即是动画之本质。所以，在一个嵌入式系统的LCD上欲显示动画，必须借助定时器。没有硬件或软件定时器的世界是无法想像的：
（1） 没有定时器，一个操作系统将无法进行时间片的轮转，于是无法进行多任务的调度，于是便不再成其为一个多任务操作系统；
（2） 没有定时器，一个多媒体播放软件将无法运作，因为它不知道何时应该切换到下一帧画面；
（3） 没有定时器，一个网络协议将无法运转，因为其无法获知何时包传输超时并重传之，无法在特定的时间完成特定的任务。
因此，没有定时器将意味着没有操作系统、没有网络、没有多媒体，这将是怎样的黑暗？所以，合理并灵活地使用各种定时器，是对一个软件人的最基本需求！
在80186为主芯片的嵌入式系统中，我们需要借助硬件定时器的中断来作为软件定时器，在中断发生后变更画面的显示内容。在时间显示"xx:xx"中让冒号交替有无，每次秒中断发生后，需调用ShowDot：
void ShowDot()
{
static BOOL bShowDot = TRUE;
if(bShowDot)
{
showChar(’:’,xPos,yPos);
}
else
{
showChar(’ ’,xPos,yPos);
}
bShowDot = ! bShowDot;
}
菜单操作
无数人为之绞尽脑汁的问题终于出现了，在这一节里，我们将看到，在C语言中哪怕用到一丁点的面向对象思想，软件结构将会有何等的改观！
笔者曾经是个笨蛋，被菜单搞晕了，给出这样的一个系统：
要求以键盘上的"← →"键切换菜单焦点，当用户在焦点处于某菜单时，若敲击键盘上的OK、CANCEL键则调用该焦点菜单对应之处理函数。我曾经傻傻地这样做着：
* 按下OK键 */
void onOkKey()
{
Switch(currentFocus)
{
case MENU1:
menu1OnOk();
break;
case MENU2:
menu2OnOk();
break;
…
}
}
void onCancelKey()
{
Switch(currentFocus)
{
case MENU1:
menu1OnCancel();
break;
case MENU2:
menu2OnCancel();
break;
…
}
}
终于有一天，我这样做了
typedef struct tagSysMenu
{
char *text;
BYTE xPos;
BYTE yPos;
void (*onOkFun)();
void (*onCancelFun)();
}SysMenu, *LPSysMenu;
当我定义菜单时，只需要这样：
static SysMenu menu[MENU_NUM] =
{
{
"menu1", 0, 48, menu1OnOk, menu1OnCancel
}
, {
" menu2", 7, 48, menu2OnOk, menu2OnCancel
}
,
{
" menu3", 7, 48, menu3OnOk, menu3OnCancel
}
,
{
" menu4", 7, 48, menu4OnOk, menu4OnCancel
}
…
};
OK键和CANCEL键的处理变成：
void onOkKey()
currentFocusMenu {
menu[].onOkFun();
}
void onCancelKey()
{
menu[currentFocusMenu].onCancelFun();
}
程序被大大简化了，也开始具有很好的可扩展性！我们仅仅利用了面向对象中的封装思想，就让程序结构清晰，其结果是几乎可以在无需修改程序的情况下在系统中添加更多的菜单，而系统的按键处理函数保持不变。
面向对象，真神了！
模拟MessageBox函数
MessageBox函数，这个Windows编程中的超级猛料，不知道是多少入门者第一次用到的函数。还记得我们第一次在Windows中利用MessageBox输出 "Hello,World!"对话框时新奇的感觉吗？无法统计，这个世界上究竟有多少程序员学习Windows编程是从MessageBox("Hello,World!",…)开始的。在我本科的学校，广泛流传着一个词汇，叫做"’Hello,World’级程序员"，意指入门级程序员，但似乎"’Hello,World’级"这个说法更搞笑而形象。
图2给出了两种永恒经典的Hello,World对话框，一种只具有"确定"，一种则包含"确定"、"取消"。是的，MessageBox的确有，而且也应该有两类！这完全是由特定的应用需求决定的。
嵌入式系统中没有给我们提供MessageBox，但是鉴于其功能强大，我们需要模拟之，一个模拟的MessageBox函数为：
******************************************
DisplayString(xPos,yPos,lpStr,TRUE);
switch (TYPE)
{
case ID_OK:
DisplayString(13,yPos+High+1, " 确定 ", 0);
break;
case ID_OKCANCEL:
DisplayString(8, yPos+High+1, " 确定 ", 0);
DisplayString(17,yPos+High+1, " 取消 ", 0);
break;
default:
break;
}
DrawRect(0, 0, 239, yPos+High+16+4);
while( (keyValue != KEY_OK) || (keyValue != KEY_CANCEL) )
{
keyValue = getSysKey();
}
if(keyValue== KEY_OK)
{
return ID_OK;
}
else
{
return ID_CANCEL;
}
}
上述函数与我们平素在VC++等中使用的MessageBox是何等的神似啊？实现这个函数，你会看到它在嵌入式系统中的妙用是无穷的。
总结
本篇是本系列文章中技巧性最深的一篇，它提供了嵌入式系统屏幕显示方面一些很巧妙的处理方法，灵活使用它们，我们将不再被LCD上凌乱不堪的显示内容所困扰。
屏幕乃嵌入式系统生存之重要辅助，面目可憎之显示将另用户逃之夭夭。屏幕编程若处理不好，将是软件中最不系统、最混乱的部分，笔者曾深受其害。
C语言嵌入式系统编程修炼之软件架构篇
模块划分
模块划分的"划"是规划的意思，意指怎样合理的将一个很大的软件划分为一系列功能独立的部分合作完成系统的需求。C语言作为一种结构化的程序设计语言，在模块的划分上主要依据功能（依功能进行划分在面向对象设计中成为一个错误，牛顿定律遇到了相对论），C语言模块化程序设计需理解如下概念：
（1） 模块即是一个.c文件和一个.h文件的结合，头文件(.h)中是对于该模块接口的声明；
（2） 某模块提供给其它模块调用的外部函数及数据需在.h中文件中冠以extern关键字声明；
（3） 模块内的函数和全局变量需在.c文件开头冠以static关键字声明；
（4） 永远不要在.h文件中定义变量！定义变量和声明变量的区别在于定义会产生内存分配的操作，是汇编阶段的概念；而声明则只是告诉包含该声明的模块在连接阶段从其它模块寻找外部函数和变量。如：
int a = 5;
#include "module1.h"
#include "module1.h"
#include "module1.h"
以上程序的结果是在模块1、2、3中都定义了整型变量a，a在不同的模块中对应不同的地址单元，这个世界上从来不需要这样的程序。正确的做法是：
*module1.h*/
extern int a;
#include "module1.h"
int a = 5;
#include "module1.h"
#include "module1.h"
这样如果模块1、2、3操作a的话，对应的是同一片内存单元。
一个嵌入式系统通常包括两类模块：
（1）硬件驱动模块，一种特定硬件对应一个模块；
（2）软件功能模块，其模块的划分应满足低偶合、高内聚的要求。
多任务还是单任务
所谓"单任务系统"是指该系统不能支持多任务并发操作，宏观串行地执行一个任务。而多任务系统则可以宏观并行（微观上可能串行）地"同时"执行多个任务。
多任务的并发执行通常依赖于一个多任务操作系统（OS），多任务OS的核心是系统调度器，它使用任务控制块（TCB）来管理任务调度功能。TCB包括任务的当前状态、优先级、要等待的事件或资源、任务程序码的起始地址、初始堆栈指针等信息。调度器在任务被激活时，要用到这些信息。此外，TCB还被用来存放任务的"上下文"（context）。任务的上下文就是当一个执行中的任务被停止时，所要保存的所有信息。通常，上下文就是计算机当前的状态，也即各个寄存器的内容。当发生任务切换时，当前运行的任务的上下文被存入TCB，并将要被执行的任务的上下文从它的TCB中取出，放入各个寄存器中。
嵌入式多任务OS的典型例子有Vxworks、ucLinux等。嵌入式OS并非遥不可及的神坛之物，我们可以用不到1000行代码实现一个针对80186处理器的功能最简单的OS内核，作者正准备进行此项工作，希望能将心得贡献给大家。
究竟选择多任务还是单任务方式，依赖于软件的体系是否庞大。例如，绝大多数手机程序都是多任务的，但也有一些小灵通的协议栈是单任务的，没有操作系统，它们的主程序轮流调用各个软件模块的处理程序，模拟多任务环境。
单任务程序典型架构
（1）从CPU复位时的指定地址开始执行；
（2）跳转至汇编代码startup处执行；
（3）跳转至用户主程序main执行，在main中完成：
a.初试化各硬件设备；
b.初始化各软件模块；
c.进入死循环（无限循环），调用各模块的处理函数
用户主程序和各模块的处理函数都以C语言完成。用户主程序最后都进入了一个死循环，其首选方案是：
while(1)
{
}
有的程序员这样写：
for(;;)
{
}
这个语法没有确切表达代码的含义，我们从for(;;)看不出什么，只有弄明白for(;;)在C语言中意味着无条件循环才明白其意。
下面是几个"著名"的死循环：
（1）操作系统是死循环；
（2）WIN32程序是死循环；
（3）嵌入式系统软件是死循环；
（4）多线程程序的线程处理函数是死循环。
你可能会辩驳，大声说："凡事都不是绝对的，2、3、4都可以不是死循环"。Yes，you are right，但是你得不到鲜花和掌声。实际上，这是一个没有太大意义的牛角尖，因为这个世界从来不需要一个处理完几个消息就喊着要OS杀死它的WIN32程序，不需要一个刚开始RUN就自行了断的嵌入式系统，不需要莫名其妙启动一个做一点事就干掉自己的线程。有时候，过于严谨制造的不是便利而是麻烦。君不见，五层的TCP/IP协议栈超越严谨的ISO/OSI七层协议栈大行其道成为事实上的标准？
经常有网友讨论：
printf("%d,%d",++i,i++);
c = a+++b;
等类似问题。面对这些问题，我们只能发出由衷的感慨：世界上还有很多有意义的事情等着我们去消化摄入的食物。
实际上，嵌入式系统要运行到世界末日。
中断服务程序
中断是嵌入式系统中重要的组成部分，但是在标准C中不包含中断。许多编译开发商在标准C上增加了对中断的支持，提供新的关键字用于标示中断服务程序(ISR)，类似于__interrupt、#program interrupt等。当一个函数被定义为ISR的时候，编译器会自动为该函数增加中断服务程序所需要的中断现场入栈和出栈代码。
中断服务程序需要满足如下要求：
(1)不能返回值；
(2)不能向ISR传递参数；
(3) ISR应该尽可能的短小精悍；
(4) printf(char * lpFormatString,…)函数会带来重入和性能问题，不能在ISR中采用。
在某项目的开发中，我们设计了一个队列，在中断服务程序中，只是将中断类型添加入该队列中，在主程序的死循环中不断扫描中断队列是否有中断，有则取出队列中的第一个中断类型，进行相应处理。
typedef struct tagIntQueue
{
int intType;
struct tagIntQueue *next;
}IntQueue;
IntQueue lpIntQueueHead;
__interrupt ISRexample ()
{
int intType;
intType = GetSystemType();
QueueAddTail(lpIntQueueHead, intType)；
}
在主程序循环中判断是否有中断：
While(1)
{
If( !IsIntQueueEmpty() )
{
intType = GetFirstInt();
switch(intType)
{
case xxx:
…
break;
case xxx:
…
break;
…
}
}
}
按上述方法设计的中断服务程序很小，实际的工作都交由主程序执行了。
硬件驱动模块
一个硬件驱动模块通常应包括如下函数：
（1）中断服务程序ISR
（2）硬件初始化
a.修改寄存器，设置硬件参数（如UART应设置其波特率，AD/DA设备应设置其采样速率等）；
b.将中断服务程序入口地址写入中断向量表：
* 设置中断向量表 */
m_myPtr = make_far_pointer(0l);
m_myPtr += ITYPE_UART;
*m_myPtr = &UART _Isr;
（3）设置CPU针对该硬件的控制线
a.如果控制线可作PIO（可编程I/O）和控制信号用，则设置CPU内部对应寄存器使其作为控制信号；
b.设置CPU内部的针对该设备的中断屏蔽位，设置中断方式（电平触发还是边缘触发）。
（4）提供一系列针对该设备的操作接口函数。例如，对于LCD，其驱动模块应提供绘制像素、画线、绘制矩阵、显示字符点阵等函数；而对于实时钟，其驱动模块则需提供获取时间、设置时间等函数。
C的面向对象化
在面向对象的语言里面，出现了类的概念。类是对特定数据的特定操作的集合体。类包含了两个范畴：数据和操作。而C语言中的struct仅仅是数据的集合，我们可以利用函数指针将struct模拟为一个包含数据和操作的"类"。下面的C程序模拟了一个最简单的"类"：
#ifndef C_Class
#define C_Class struct
#endif
C_Class A
{
C_Class A *A_this;
void (*Foo)(C_Class A *A_this);
int a;
int b;
};
我们可以利用C语言模拟出面向对象的三个特性：封装、继承和多态，但是更多的时候，我们只是需要将数据与行为封装以解决软件结构混乱的问题。C模拟面向对象思想的目的不在于模拟行为本身，而在于解决某些情况下使用C语言编程时程序整体框架结构分散、数据和函数脱节的问题。我们在后续章节会看到这样的例子。
总结
本篇介绍了嵌入式系统编程软件架构方面的知识，主要包括模块划分、多任务还是单任务选取、单任务程序典型架构、中断服务程序、硬件驱动模块设计等，从宏观上给出了一个嵌入式系统软件所包含的主要元素。
请记住：软件结构是软件的灵魂！结构混乱的程序面目可憎，调试、测试、维护、升级都极度困难。
C语言嵌入式系统编程修炼之性能优化
使用宏定义
在C语言中，宏是产生内嵌代码的唯一方法。对于嵌入式系统而言，为了能达到性能要求，宏是一种很好的代替函数的方法。
写一个"标准"宏MIN ，这个宏输入两个参数并返回较小的一个：
错误做法：
#define MIN(A,B) ( A <= B ? A : B )
正确做法：
#define MIN(A,B) （（A）<= (B) ? (A) : (B) ）
对于宏，我们需要知道三点：
(1)宏定义"像"函数；
(2)宏定义不是函数，因而需要括上所有"参数"；
(3)宏定义可能产生副作用。
下面的代码：
least = MIN(*p++, b);
将被替换为：
( (*p++) <= (b) ?(*p++):(b) )
发生的事情无法预料。
因而不要给宏定义传入有副作用的"参数"。
使用寄存器变量
当对一个变量频繁被读写时，需要反复访问内存，从而花费大量的存取时间。为此，C语言提供了一种变量，即寄存器变量。这种变量存放在CPU的寄存器中，使用时，不需要访问内存，而直接从寄存器中读写，从而提高效率。寄存器变量的说明符是register。对于循环次数较多的循环控制变量及循环体内反复使用的变量均可定义为寄存器变量，而循环计数是应用寄存器变量的最好候选者。
(1) 只有局部自动变量和形参才可以定义为寄存器变量。因为寄存器变量属于动态存储方式，凡需要采用静态存储方式的量都不能定义为寄存器变量，包括：模块间全局变量、模块内全局变量、局部static变量；
(2) register是一个"建议"型关键字，意指程序建议该变量放在寄存器中，但最终该变量可能因为条件不满足并未成为寄存器变量，而是被放在了存储器中，但编译器中并不报错（在C++语言中有另一个"建议"型关键字：inline）。
下面是一个采用寄存器变量的例子：
* 求1+2+3+….+n的值 */
WORD Addition(BYTE n)
{
register i,s=0;
for(i=1;i<=n;i++)
{
s=s+i;
}
return s;
}
本程序循环n次，i和s都被频繁使用，因此可定义为寄存器变量。
内嵌汇编
程序中对时间要求苛刻的部分可以用内嵌汇编来重写，以带来速度上的显著提高。但是，开发和测试汇编代码是一件辛苦的工作，它将花费更长的时间，因而要慎重选择要用汇编的部分。
在程序中，存在一个80-20原则，即20%的程序消耗了80%的运行时间，因而我们要改进效率，最主要是考虑改进那20%的代码。
嵌入式C程序中主要使用在线汇编，即在C程序中直接插入_asm{ }内嵌汇编语句：
* 把两个输入参数的值相加，结果存放到另外一个全局变量中 */
int result;
void Add(long a, long *b)
{
_asm
{
MOV AX, a
MOV BX, b
ADD AX, [BX]
MOV result, AX
}
}
利用硬件特性
首先要明白CPU对各种存储器的访问速度，基本上是：
CPU内部RAM > 外部同步RAM > 外部异步RAM > FLASH/ROM
对于程序代码，已经被烧录在FLASH或ROM中，我们可以让CPU直接从其中读取代码执行，但通常这不是一个好办法，我们最好在系统启动后将FLASH或ROM中的目标代码拷贝入RAM中后再执行以提高取指令速度；
对于UART等设备，其内部有一定容量的接收BUFFER，我们应尽量在BUFFER被占满后再向CPU提出中断。例如计算机终端在向目标机通过RS-232传递数据时，不宜设置UART只接收到一个BYTE就向CPU提中断，从而无谓浪费中断处理时间；
如果对某设备能采取DMA方式读取，就采用DMA读取，DMA读取方式在读取目标中包含的存储信息较大时效率较高，其数据传输的基本单位是块，而所传输的数据是从设备直接送入内存的（或者相反）。DMA方式较之中断驱动方式，减少了CPU 对外设的干预，进一步提高了CPU与外设的并行操作程度。
活用位操作
使用C语言的位操作可以减少除法和取模的运算。在计算机程序中数据的位是可以操作的最小数据单位，理论上可以用"位运算"来完成所有的运算和操作，因而，灵活的位操作可以有效地提高程序运行的效率。举例如下：
l
int i,j;
i = 879 / 16;
j = 562 % 32;
int i,j;
i = 879 >> 4;
j = 562 - (562 >> 5 << 5);
对于以2的指数次方为"*"、"/"或"%"因子的数学运算，转化为移位运算"<< >>"通常可以提高算法效率。因为乘除运算指令周期通常比移位运算大。
C语言位运算除了可以提高运算效率外，在嵌入式系统的编程中，它的另一个最典型的应用，而且十分广泛地正在被使用着的是位间的与（&）、或（|）、非（~）操作，这跟嵌入式系统的编程特点有很大关系。我们通常要对硬件寄存器进行位设置，譬如，我们通过将AM186ER型80186处理器的中断屏蔽控制寄存器的第低6位设置为0（开中断2），最通用的做法是：
#define INT_I2_MASK 0x0040
wTemp = inword(INT_MASK);
outword(INT_MASK, wTemp &~INT_I2_MASK);
而将该位设置为1的做法是：
#define INT_I2_MASK 0x0040
wTemp = inword(INT_MASK);
outword(INT_MASK, wTemp | INT_I2_MASK);
判断该位是否为1的做法是：
#define INT_I2_MASK 0x0040
wTemp = inword(INT_MASK);
if(wTemp & INT_I2_MASK)
{
…
}
上述方法在嵌入式系统的编程中是非常常见的，我们需要牢固掌握。
总结
在性能优化方面永远注意80-20准备，不要优化程序中开销不大的那80%，这是劳而无功的。
宏定义是C语言中实现类似函数功能而又不具函数调用和返回开销的较好方法，但宏在本质上不是函数，因而要防止宏展开后出现不可预料的结果，对宏的定义和使用要慎而处之。很遗憾，标准C至今没有包括C++中inline函数的功能，inline函数兼具无调用开销和安全的优点。
使用寄存器变量、内嵌汇编和活用位操作也是提高程序效率的有效方法。
除了编程上的技巧外，为提高系统的运行效率，我们通常也需要最大可能地利用各种硬件设备自身的特点来减小其运转开销，例如减小中断次数、利用DMA传输方式等。
- C底层编程
- 学习较底层编程：动手写一个C语言编译器
- 学习较底层编程：动手写一个C语言编译器
- 学习较底层编程：动手写一个C语言编译器
- 学习较底层编程：动手写一个C语言编译器
- 学习较底层编程：动手写一个C语言编译器
- 学习较底层编程：动手写一个C语言编译器
- 底层编程 - 检测鼠标
- 底层编程 - 时间陷阱
- windows底层编程基础
- C专家编程精华第二篇----C对内存的使用，底层探索
- c底层操作
- extern "C"底层原理
- 向C底层进军~~~
- 高层和底层C
- C语言底层操作
- Objective-C底层数据结构
- c 语言 底层 笔记
- 人脸识别 代码解析
- diff函数(matlab)
- SVN服务器客户端以及环境的搭建和使用
- 第06章-图像处理及可视化（1）
- 黑马程序员_泛型
- C底层编程
- 一道经常遇到的面试编程题，字符串逆序输出
- php学习之道：php empty()和isset()的区别
- Download interrupted: Connection to https://dl-ssl.google.com refused
- latex 公式对齐
- Linux ALSA声卡驱动之三：PCM设备的创建
- 今日作息及食谱(7.14)
- Spring使用JdbcTemplate实现对数据库操作
- 理解RESTful架构
