C语言，#define语句的用法。_百度知道
C语言，#define语句的用法。
MY_GLOBALS
MY_EXT u16 PAGE1 FBV
MY_EXT u16 PAGE2 QuitDefrostT
MY_EXT u16 PAGE2 FanS
MY_EXT u16 PAGE2 FanO
MY_EXT u8 PAGE2 F
MY_EXT u16 PAGE2 FeedB...
我有更好的答案
1.简单的宏定义 格式：#define 标识符 替换列表 说明：替换列表可以是数，字符串字面量，标点符号，运算符，标识符，关键字，字符常量。 注意：替换列表是可以为空的 典型错误： #define&N&=&100 int&a[N];&/*这样会成为int&a[=&100],这里会处理成为一种标识记号一样*/ #define&N&100; int&a[N];&/*带分号的定义会成为int&a[100;],这是一种很常见的错误*/ #define&pin&(int*); pin&a,b; int*&a,b;&/*本意是a和b都是int型指针，但是实际上变成int*&a,b;a是int型指针，而b是int型变量。这是应该使用typedef来代替define，这样a和b就都是int型指针了。*/ 典型的使用方法： 使用宏定义可以自己根据自己的习惯来定义甚至改变C语言的语法习惯，例如：&&&&#define&BEGIN&{ #define&END&} int&main()BEGIN printf&(&DEFINE----\n&); END 定义一个循环 #define&LOOP&for(;;) 重新定义数据类型 #define&IT&int 2.带参数的宏 #define 标识符（x1,x2,x3...xn） 替换列表 &（注意：x1,x2,x3..是宏的参数，标识符和其左括弧之间不能有空格） 使用方法： #define&MAX(x,y)&((x)&(y)?(x):(y)) i=MAX(j+k,m-n); 替换为： i=MAX((j+k)&(m-n)?(j+k):(m-n)); #define&SI_EX(n)&((n)%2==0) if(SI_EX(i))&i++; 替换为： &if(SI_EX((i)%2==0)) 通过以上例子可以看出，标识符带参数（X1，X2，X3.....）在替换时会被替换列表（Y1，Y2，Y3....）对应的替换，但是和顺序无关。 3.宏的特殊单行定义 #define&A(x)&T_##x #define&B（x)&#@x #define&C（x)&#x x=1 替换为： A(1)------& T_1 （T_##x,##符号是记号粘黏符号，将前后的字符粘黏起来。） B(1)------& '1' （ #@x , #@ 符号会将宏的参数进行字符串字面量化，并且加‘’号） C(1)------& &1& （ #x ,#符号会将宏的参数进行字符串字面量化，并且加&&号） 4.define的多行定义 define可以替代多行的代码，在每一个换行的时候加上一个&\& &#define&MAX(X,Y)&do&{&\ 语句1;&\ 语句2;&\ /*&注释的写法&*/&\ }&while(0)&/*&(no&trailing&;&)&*/&\ 5.在大规模的开发过程中，特别是跨平台和系统的软件里，define最重要的功能是条件编译。 #ifdef&WINDOWS ...... ...... #endif #ifdef&LINUX ...... ...... #endif 可以在编译的时候通过#define设置编译环境 6.取消宏 #undef&标识符 7.条件编译 #ifdef&XXX…(#else)&…&#endif 8.预定义宏 在C语言中收录了一些有用的宏，这些宏是提供当前编译信息的。 __LINE__ & & & &被编译文件的行数 （整型） __FILE__ &被编译文件的名字 （字符型） __DATE__ &编译日期 （字符型） __TIME__ &编译时间 （字符型） __STDC__ &如果编译器接受标准C，那么值为1. （整型） 通常在编译的时候可以用这些预定义的宏来进行排错，例如： 一般情况下，当出现除零的情况时编译器是没有提示的，可以自定义一个解决办法。 #define&CHECKZERO(divisor)\ if(divisor==0)\ printf(&***ATTEMPT&TO&DIVIDE&BY&ZERO&IN&LINE&%d&of&file&%s&***\n&,__LINE__,__FILE__);\ 引用方法 CHECKZERO(j); k=i/j;
网络管理与维护
这种预编译方式是为了防止重复编译，意思是，如果你预先定义了MY_GLOBALS，则MY_EXT就在本文件下有效，否则就为extern型，在本文件夹下的其他文件下也可以引用
请问一下PAGE这个是什么意思？什么语句哦？这也是人家的程序。您能猜到么？
u8 与 u16应该是8 位和 16位的类型，这里做了类型的转换，是为了将程序移植在其他平台上，至于PAGE，从字面意思和经验，应该指的是页面，结合前面的u8和u16 ，初步确定是某种平台上的说句类型
本回答被提问者采纳
1.简单的define定义#define MAXTIME 1000 一个简单的MAXTIME就定义好了，它代表1000，如果在程序里面写if(i&MAXTIME){.........}编译器在处理这个代码之前会对MAXTIME进行处理替换为1000。这样的定义看起来类似于普通的常量定义CONST，但也有着不同，因为define的定义更像是简单的文本替换，而不是作为一个量来使用，这个问题在下面反映的尤为突出。2.define的“函数定义”define可以像函数那样接受一些参数，如下#define max(x,y) (x)&(y)?(x):(y);这个定义就将返回两个数中较大的那个，看到了吗？因为这个“函数”没有类型检查，就好像一个函数模板似的，当然，它绝对没有模板那么安全就是了。可以作为一个简单的模板来使用而已。但是这样做的话存在隐患，例子如下：#define Add(a,b) a+b;在一般使用的时候是没有问题的，但是如果遇到如：c * Add(a,b) * d的时候就会出现问题，代数式的本意是a+b然后去和c，d相乘，但是因为使用了define（它只是一个简单的替换），所以式子实际上变成了c*a + b*d另外举一个例子：#define pin (int*);pin a,b;本意是a和b都是int型指针，但是实际上变成int* a,b;a是int型指针，而b是int型变量。这是应该使用typedef来代替define，这样a和b就都是int型指针了。所以我们在定义的时候，养成一个良好的习惯，建议所有的层次都要加括号。3.宏的单行定义#define A(x) T_##x#define B（x) #@x#define C（x) #x我们假设：x=1，则有：A(1)------〉T_1B(1)------〉'1'C(1)------〉&1&（这里参考了 hustli的文章）3.define的多行定义define可以替代多行的代码，例如MFC中的宏定义（非常的经典，虽然让人看了恶心）#define MACRO(arg1, arg2) do { //* declarations */ /stmt1; /stmt2; //* ... */ /} while(0) /* ( ) */关键是要在每一个换行的时候加上一个&/&
本回答被网友采纳
带参宏定义
c语言允许宏带有参数。在宏定义中的参数称为形式参数，在宏调用中的参数称为实际参数。对带参数的宏，在调用中，不仅要宏展开，而且要用实参去代换形参。
带参宏定义的一般形式为：
#define 宏名(形参表) 字符串
在字符串中含有各个形参。
带参宏调用的一般形式为：
宏名(形参表)
#define M(y) ((y)*(y)+3*(y) /*宏定义*/
k=M(5); /*宏调用*/
在宏调用时，用实参5去代替形参y，经预处理宏展开后的语句为:
#define MAX(a,b) (a&b)?a:b
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的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。查看: 1580|回复: 6
原子哥可以帮忙解释这些函数的意义吗？只看懂了（void*）是把后面的强制转换指针形式，但是后面那个函数名字符串是什么意思了》？
主题帖子精华
初级会员, 积分 72, 距离下一级还需 128 积分
在线时间0 小时
(void*)delay_ms,"void delay_ms(u16 nms)",
& (void*)delay_us,"void delay_us(u32 nus)", &
(void*)LCD_Clear,"void LCD_Clear(u16 Color)",
(void*)LCD_Fill,"void LCD_Fill(u16 xsta,u16 ysta,u16 xend,u16 yend,u16 color)",
(void*)LCD_DrawLine,"void LCD_DrawLine(u16 x1, u16 y1, u16 x2, u16 y2)",
(void*)LCD_DrawRectangle,"void LCD_DrawRectangle(u16 x1, u16 y1, u16 x2, u16 y2)",
(void*)LCD_Draw_Circle,"void Draw_Circle(u16 x0,u16 y0,u8 r)",
(void*)LCD_ShowNum,"void LCD_ShowNum(u16 x,u16 y,u32 num,u8 len,u8 size)",
(void*)LCD_ShowString,"void LCD_ShowString(u16 x,u16 y,u16 width,u16 height,u8 size,u8 *p)",
(void*)LCD_Fast_DrawPoint,"void LCD_Fast_DrawPoint(u16 x,u16 y,u16 color)",
(void*)LCD_ReadPoint,"u16 LCD_ReadPoint(u16 x,u16 y)",
(void*)LCD_Display_Dir,"void LCD_Display_Dir(u8 dir)",
(void*)LCD_ShowxNum,"void LCD_ShowxNum(u16 x,u16 y,u32 num,u8 len,u8 size,u8 mode)",
(void*)led_set,"void led_set(u8 sta)",
(void*)test_fun,"void test_fun(void(*ledset)(u8),u8 sta)",
这是usmart里面的东西，第一个是函数，第二个是函数的字符串 。
看不懂没关系，会用就行了。依葫芦画瓢用就可以了。
不会设计就抄呗，抄着抄着就会了。
主题帖子精华
金钱126400
在线时间1089 小时
这是usmart里面的东西，第一个是函数，第二个是函数的字符串 。
看不懂没关系，会用就行了。依葫芦画瓢用就可以了。
我是开源电子网www.openedv.com站长，有关站务问题请与我联系。
正点原子STM32开发板购买店铺：
微信公众平台：正点原子& &
主题帖子精华
初级会员, 积分 99, 距离下一级还需 101 积分
在线时间18 小时
dca598a404d_403.png (0 Bytes, 下载次数: 1)
22:54 上传
在这边输出到串口。。。
主题帖子精华
初级会员, 积分 72, 距离下一级还需 128 积分
在线时间0 小时
回复【2楼】正点原子:
---------------------------------
&&哦哦哦，画瓢是会了，&但是还是想懂这个意思。嘿嘿~~
不会设计就抄呗，抄着抄着就会了。
主题帖子精华
初级会员, 积分 72, 距离下一级还需 128 积分
在线时间0 小时
回复【3楼】小杰:
---------------------------------
哦，&你是说这个只是用在STM32给PC发送函数的名称而已吗？就是那个list，就会出现所有的函数名打印在串口上！~？
不会设计就抄呗，抄着抄着就会了。
主题帖子精华
初级会员, 积分 99, 距离下一级还需 101 积分
在线时间18 小时
回复【5楼】菜鸟爱学习:
---------------------------------
对啊对啊。。
主题帖子精华
初级会员, 积分 72, 距离下一级还需 128 积分
在线时间0 小时
回复【6楼】小杰:
---------------------------------
哦哦，&谢谢啦！！
不会设计就抄呗，抄着抄着就会了。
Powered by有关stm32的问题，程序里面的u8、u16这些是什么意思啊_百度知道
有关stm32的问题，程序里面的u8、u16这些是什么意思啊
貌似看起来像是一种定义变量的方法，学过c语言，可是定义变量有些用u8，有些用u16，可能还有u32的，那u8、u16、u32有什么区别啊，求教~~~
我有更好的答案
u8 是 unsigned charu16 是 unsigned shortu32 是 unsigned int 这些都是变量类型，你可以找本c语言的书看看
采纳率：24%
u8，u16，u32都是unsigned char类型，不过u8是一个字节的，u16 是2字节，u32是4字节typedef signed char
int8_t;typedef signed short int
int16_t;typedef signed int
int32_t;typedef signed __int64
/* exact-width unsigned integer types */typedef unsigned char
uint8_t;typedef unsigned short int
uint16_t;typedef unsigned int
uint32_t;typedef unsigned __int64
uint64_t;typedef int32_t
s32;typedef int16_t
s16;typedef int8_t
s8;typedef uint32_t
u32;typedef uint16_t
u16;typedef uint8_t
头文件里有定义
你看看 我也不记得了
为您推荐：
其他类似问题
您可能关注的内容
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。C语言关键字
auto ：声明自动变量 一般不使用
auto被解释为一个自动存储变量的关键字，也就是申明一块临时的变量内存。
auto int a=4;
表示a为一个自动存储的临时变量。
作用：C程序是面向过程的，在C代码中会出现大量的函数模块，每个函数都有其生命周期（也称作用域），在函数生命周期中声明的变量通常叫做局部变量，也叫自动变量。例如：
int fun(){
int a = 10;
// auto int a = 10;
// do something
整型变量a在fun函数内声明，其作用域为fun函数内，出来fun函数，不能被引用，a变量为自动变量。也就是说编译器会有int a = 10之前会加上auto的关键字。
auto的出现意味着，当前变量的作用域为当前函数或代码段的局部变量，意味着当前变量会在内存栈上进行分配。
如果大家学过数据结构，应该知道，栈就是先进后出的数据结构。它类似于我们用箱子打包书本，第一本扔进去大英，第二本扔进行高数，第三本扔进行小说，那么取书的时候，先取出来第一本是小说，第二是高数，第三本是大英。
栈的操作为入栈和出栈，入栈就是向箱子里扔书，出栈就是从箱子里取书。那么这和我们的auto变量分配空间有什么关系呢？
由于一个程序中可能会有大量的变量声明，每个变量都会占有一定的内存空间，而内存空间对于计算机来说是宝贵的硬件资源，因此合理的利用内存是编译器要做的一个主要任务。有的变量是一次性使用的，如局部变量。有的变量要伴随着整个程序来使用的，如全局变量。为了节省内存空间，优化性能，编译器通常会将一次性使用的变量分配在栈上。也就是说，代码中声明一个一次性变量，就在栈上进行入栈操作。当该变量使用完了（生命周期结束），进行出栈操作。这样，在执行不同的函数的时候，就会在一个栈上进行出入栈操作，也就是说它们在频繁的使用一个相同的内存空间，从而可以更高效的利用内存。
double ：声明双精度变量或函数
C语言中,双精度浮点(double)型，占8 个字节（64位）内存空间。其数值范围为1.7E-308～1.7E+308，双精度完全保证的有效数字是15位，16位只是部分数值有保证，而单精度保证7位有效数字，部分数值有8位有效数.
浮点型从狭义上说就是科学记数法
双精度，即 double 。 double有二，两个的意思。
C 标准要求 float 类型至少要能精确表示到小数点后6位，并且整数部分的表示范围至少要达到 1.0-37 & 10+37 。float 一般是 32 位的。
C 标准规定double 类型的整数部分的最小表示范围和 float 一样，都是 1.0E-37 到 1.0E+37，但是它要求 double 类型的小数部分至少要能精确到小数点后 10 位。double 通常是 64 位的。
long double
C 还提供了 long double 类型，目的是提供一种比 double 更加精确的类型。
然而，C 标准仅仅规定 long double 至少要和 double 一样精确。
double a=5.22;
int： 声明整型变量或函数
C/C++语言中，int表示整型变量，是一种数据类型，用于定义一个整型变量，在不同编译环境有不同的大小，不同编译运行环境大小不同。在32/64位中都是32位，范围为-~+，无符号情况下表示为0~。
struct：声明结构体变量或函数
基本定义：结构体，通俗讲就像是打包封装，把一些有共同特征（比如同属于某一类事物的属性，往往是某种业务相关属性的聚合）的变量封装在内部，通过一定方法访问修改内部变量。
&结构&是一种构造类型，它是由若干&成员&组成的。 每一个成员可以是一个基本数据类型或者又是一个构造类型。 结构即是一种&构造&而成的数据类型， 那么在说明和使用之前必须先定义它，也就是构造它。如同在说明和调用函数之前要先定义一样。
定义一个结构的一般形式为：
struct 结构名
//成员表列
成员表由若干个成员组成， 每个成员都是该结构的一个组成部分。对每个成员也必须作类型说明，其形式为：
类型说明符 成员名;
成员名的命名应符合标识符的书写规定。
struct stu
char name[20];
在这个结构定义中，结构名为stu，该结构由4个成员组成。 第一个成员为num，整型变量；第二个成员为name，字符型https://blog.csdn.net/a193314/article/details/数组；第三个成员为sex，字符型变量；第四个成员为score，浮点型变量。 应注意在括号后的分号是必不可少的。
值得一提的是，在C++中，struct的功能得到了强化，struct不仅可以添加成员变量，还可以添加成员函数，和class类似。所以完全可以利用结构提封装出C++的一些特性，引入面向对象的C写法。
对于结构体的sizeof计算需要理解内存对齐问题。
break：跳出当前循环
break语句通常用在循环语句和开关语句中。当break用于开关语句switch中时，可使程序跳出switch而执行switch以后的语句；如果没有break语句，则会从满足条件的地方（即与switch（表达式）括号中表达式匹配的case）开始执行，直到switch结构结束。
当break语句用于do-while、for、while循环语句中时，可使程序终止循环。而执行循环后面的语句，通常break语句总是与if语句联在一起。即满足条件时便跳出循环。
int main(void)
while(1) /*设置循环*/
c='\0'; /*变量赋初值*/
while(c!=13&&c!=27) /*键盘接收字符直到按回车或Esc键*/
c=getch();
printf(&%c\n&,c);
/*判断若按Esc键则退出循环*/
printf(&The No. is %d\n&,i);
printf(&The end&);
1. break语句对if-else的条件语句不起作用。
2. 在多层循环中，一个break语句只向外跳一层。
if else ：条件分支语句
if语句是指C语言中用来判定所给定的条件是否满足，根据判定的结果（真或假）决定执行给出的两种操作之一。
提供了三种形式的if语句：
1、if（表达式）语句。
printf(&%d&,x);
if（表达式）语句1 else 语句2
printf(&%d&,x);
printf(&%d&,y);
3、if（表达式1）
else if（表达式2）
else if（表达式3）
else if（表达式m）
//do something
else if(1==i)
//do something
else if(2==i)
//do something
//do something
在每个语句中，可以有多个语句，但需要加上大括号
printf(&%d&,x);
//do somethings
if(x==y||x==z)
//do somethings
if(1==x&&1==y)
//do somethings
long ：声明长整型变量或函数
取值范围：
1. unsigned long 0～
2. long ～
3. long long的最大值：4775807
4. long long的最小值：-4775808
5. unsigned long long的最大值：
6. long 是C语言的一个关键字，代表一种数据类型，中文为长整型。
7. long是long int的简写，也就是说，在C语言中long int类型和long类型是相同的。
8. 每个long型占4个字节，在32位编译系统下，long和int占的空间是相同的。这也导致了long型变量使用的越来越少了。
9. long型可以表示的整型数字范围为-2,147,483,648 ~ 2,147,483,647, 即-2^32 ~ 2^32-1。在用在C的格式化输入输出时，long型的格式化字符为&%ld&。
10. long同其它整型类型一样，可以同unsigned 联合使用，形成unsigned long，即无符号长整型, 其格式化字符为&%lu&。
11. 在部分编译器下，比如gcc， 两个long合用,即long long类型，表示C语言目前最长的系统整型类型，每个long long类型占8字节，64位。其格式化字符为&%lld&。
switch case：开关语句
其一般形式为：
switch(表达式)
case 常量表达式1:
case 常量表达式2:
case 常量表达式n:
其语义是：计算表达式的值。 并逐个与其后的常量表达式值相比较，当表达式的值与某个常量表达式的值相等时， 即执行其后的语句，然后不再进行判断，继续执行后面所有case后的语句。如表达式的值与所有case后的常量表达式均不相同时，则执行default后的语句。
int main(void)
printf(&input integer number:
scanf(&%d&,&a);
switch (a){
printf(&Monday\n&);
printf(&Tuesday\n&);
printf(&Wednesday\n&);
printf(&Thursday\n&);
printf(&Friday\n&);
printf(&Saturday\n&);
printf(&Sunday\n&);
printf(&error\n&);
根据不同的场合选择是否需要break；case 语句用{}包含起来也有作用域的效果，也可多层嵌套。
enum ：声明枚举类型
enum是计算机编程语言中的一种数据类型。枚举类型：在实际问题中，有些变量的取值被限定在一个有限的范围内。例如，一个星期内只有七天，一年只有十二个月，一个班每周有六门课程等等。如果把这些量说明为整型，字符型或其它类型显然是不妥当的。为此，C语言提供了一种称为&枚举&的类型。在&枚举&类型的定义中列举出所有可能的取值，被说明为该&枚举&类型的变量取值不能超过定义的范围。应该说明的是，枚举类型是一种基本数据类型，而不是一种构造类型，因为它不能再分解为任何基本类型。
定义说明：
1. 枚举类型定义的一般形式为：
enum 枚举名
在枚举值表中应罗列出所有可用值。这些值也称为枚举元素。
该枚举名为weekday，枚举值共有7个，即一周中的七天。凡被说明为weekday类型变量的取值只能是七天中的某一天。
2. 枚举变量的说明
如同结构体（struct）和共用体（union）一样，枚举变量也可用不同的方式说明，即先定义后说明，同时定义说明或直接说明。
设有变量a,b,c被说明为上述的weekday，可采用下述任一种方式：
enum weekday
enum weekday a,b,c;
//或者为：
enum weekday
//或者为：
sun, //start 默认为0
内存空间：
enum是枚举型 union是共用体，成员共用一个变量缓冲区。
赋值和使用：
枚举类型在使用中有以下规定：
1. 枚举值是常量，不是变量。不能在程序中用赋值语句再对它赋值。
2. 枚举元素本身由系统定义了一个表示序号的数值，从0开始顺序定0，1，2&。如在weekday中，sun值为0，mon值为1，sat值为6。
只能把枚举值赋予枚举变量，不能把元素的数值直接赋予枚举变量。如一定要把数值赋予枚举变量，则必须用强制类型转换。
a=(enum weekday)2;
其意义是将顺序号为2的枚举元素赋予枚举变量a，相当于：
还应该说明的是枚举元素不是字符常量也不是字符串常量，使用时不要加单、双引号。
register：声明积存器变量
这个关键字请求编译器尽可能的将变量存在CPU内部寄存器中，而不是通过内存寻址访问，以提高效率。注意是尽可能，不是绝对。你想想，一个CPU 的寄存器也就那么几个或几十个，你要是定义了很多很多register 变量，它累死也可能不能全部把这些变量放入寄存器吧，轮也可能轮不到你。
一、寄存器
寄存器是个中转站，并无别的功能。大部分情况应用于驱动编写，对处理速度有较高要求的地方。
register修饰符暗示编译程序相应的变量将被频繁地使用，如果可能的话，应将其保存在CPU的寄存器中，以加快其存储速度。例如下面的内存块拷贝代码，
memcpy (d, s, l)
register char *d;
register char *s;
while (i--)
*d++ = *s++;
三、使用register 修饰符的注意点
但是使用register修饰符有几点限制。
首先，register变量必须是能被CPU所接受的类型。这通常意味着register变量必须是一个单个的值，并且长度应该小于或者等于整型的长度。不过，有些机器的寄存器也能存放浮点数。
其次，因为register变量可能不存放在内存中，所以不能用&&&来获取register变量的地址。
由于寄存器的数量有限，而且某些寄存器只能接受特定类型的数据（如指针和浮点数），因此真正起作用的register修饰符的数目和类型都依赖于运行程序的机器，而任何多余的register修饰符都将被编译程序所忽略。
在某些情况下，把变量保存在寄存器中反而会降低程序的运行速度。因为被占用的寄存器不能再用于其它目的；或者变量被使用的次数不够多，不足以装入和存储变量所带来的额外开销。
早期的C编译程序不会把变量保存在寄存器中，除非你命令它这样做，这时register修饰符是C语言的一种很有价值的补充。然而，随着编译程序设计技术的进步，在决定那些变量应该被存到寄存器中时，现在的C编译环境能比程序员做出更好的决定。实际上，许多编译程序都会忽略register修饰符，因为尽管它完全合法，但它仅仅是暗示而不是命令。
typedef：用以给数据类型取别名（当然还有其他作用）
typedef 声明，简称 typedef，为现有类型创建一个新的名字。比如人们常常使用 typedef 来编写更美观和可读的代码。所谓美观，意指 typedef 能隐藏笨拙的语法构造以及平台相关的数据类型，从而增强可移植性和以及未来的可维护性。
常见用法：
1.常规变量类型定义
例如：typedef unsigned char uchar
描述：uchar等价于unsigned char类型定义
uchar c声明等于unsigned char c声明
2.https://blog.csdn.net/a193314/article/details/数组类型定义
例如： typedef int array[2];
描述： array等价于 int [2]定义;
array a声明等价于int a[2]声明
扩展： typedef int array[M][N];
描述： array等价于 int [M][N]定义;
array a声明等价于int a[M][N]声明
3.指针类型定义
例如： typedef int *
描述： pointer等价于 int *定义;
pointer p声明等价于int *a声明
例如： typedef int *pointer[M];
描述： pointer等价于 int *[M]定义;
pointer p声明等价于int *a[M]声明明
4.函数地址说明
描述：C把函数名字当做函数的首地址来对待，我们可以使用最简单的方法得到函数地址
例如： 函数:int func(void);
unsigned long funcAddr=(unsigned long)func；
funcAddr的值是func函数的首地址
5.函数声明
例如： typedef int func(void);
func等价于 int (void)类型函数
描述1： func f声明等价于 int f(void)声明，用于文件的函数声明
描述2： func *pf声明等价于 int (*pf)(void)声明，用于函数指针的生命，见下一条
6.函数指针
例如： typedef int (*func)(void)
描述： func等价于int (*)(void)类型
func pf等价于int (*pf)(void)声明，pf是一个函数指针变量
7.识别typedef的方法：
a).第一步。使用已知的类型定义替代typdef后面的名称,直到只剩下一个名字不识别为正确
如typedef u32 (*func)(u8);
从上面的定义中找到 typedef __u32 u32;typedef __u8 u8
继续找到 typedef unsigned int __u32;typedef unsigned char __u8;
替代位置名称 typedef unsigned int (*func)(void);
现在只有func属于未知
b).第二步.未知名字为定义类型，类型为取出名称和typedef的所有部分，如上为
func等价于unsigned unsigned int (*)(unsigned char);
c).第三部.定义一个变量时，变量类型等价于把变量替代未知名字的位置所得到的类型func f等价于unsigned unsigned int (*f)(unsigned char)
char ：声明字符型变量或函数
C语言基本类型:字符型(char)用法介绍
1.字符型（char）简介
字符型（char）用于储存字符（character），如英文字母或标点。严格来说，char 其实也是整数类型（integer type），因为 char 类型储存的实际上是整数，而不是字符。计算机使用特定的整数编码来表示特定的字符。美国普遍使用的编码是 ASCII（American Standard Code for Information Interchange 美国信息交换标准编码）。例如：ASCII 使用 65 来代表大写字母 A，因此存储字母 A 实际上存储的是整数65。注意：许多IBM大型机使用另一种编码&&EBCDIC（Extended Binary-Coded Decimal Interchange Code 扩充的二进制编码的十进制交换码）；不同国家的计算机使用的编码可能完全不同。
ASCII 的范围是 0 到 127，故而 7 位（bit）就足以表示全部 ASCII。char 一般占用 8 位内存单元，表示ASCII绰绰有余。许多系统都提供扩展ASCII（Extended ASCII），并且所需空间仍然在 8 位以内。注意，不同的系统提供的扩展 ASCII 的编码方式可能有所不同！
许多字符集超出了 8 位所能表示的范围（例如汉字字符集），使用这种字符集作为基本字符集的系统中，char 可能是 16 位的，甚至可能是 32 位的。总之，C 保证 char 占用空间的大小足以储存系统所用的基本字符集的编码。C 语言定义一个字节（byte）的位数为 char 的位数，所以一个字节可能是 16 位，也可能是 32 位，而不仅仅限于 8 位。
2. 声明字符型变量字符型变量的声明方式和其它类型变量的声明方式一样：
char better,
以上代码声明了三个字符型变量：good、better，和 best。
3. 字符常量与初始化
我们可以使用以下语句来初始化字符型变量：
char ch = 'A';
这个语句把 ch 的值初始化为 A 的编码值。在这个语句中，&A& 是字符常量。C 语言中，使用单引号把字符引起来就构成字符常量。我们来看另外一个例子：
/* 声明一个字符型变量
fail = 'F';
fail = &F&;
/* 错！&F& 是字符串字面量
把字符用双引号引起来构成字符串字面量，所以第三个语句是错误的。我们会在后续的教程中讨论字符串，现在暂且把它放下。
因为字符实质上是以数字的形式存储的，所以我们可以直接使用数字来初始化字符变量，或者给字符变量赋值：
在 ASCII 中，A 的编码是 65，所以对于使用 ASCII 的系统来说，这个语句等同于 char ch = &A&;。使用非 ASCII 的系统中，65 代表的不一定是 A，而有可能是其它任何字符，所以使用数字来初始化字符变量，或者给字符变量赋值是一种不好的风格，因为移植性太差了！但是，使用字符常量（例如 &A&）来初始化字符变量，或者给字符变量赋值，字符变量得到的一定是我们所期待的字符的编码值。例如：
char ch = 'A';
无论在使用任何编码的系统中，ch 都能够得到字符 A 所对应的编码值。这是因为编译器会自动把 &A& 转化成 A 所对应的编码值。因此，我们应该使用字符常量来初始化字符变量，或者给字符变量赋值；而不要用数字。
有趣的是，C 使用 int 类型来处理字符常量，而不是 char 类型。例如，在使用32位 int 的ASCII 系统中，以下代码
char ch = 'C';
的编码值 67 被存储于 32 位的内存单元中；不过 ch 仍然存储于 8 位的内存单元中，只是它的值变成了 67。因此，我们可以定义形如 &good& 的古怪字符常量。因为每个字符的编码值占用 8 位的内存单元，所以这个常量刚好可以存储于 32 位的内存单元。然而，用这种字符常量初始化字符变量，或者给字符变量赋值的话，导致的结果是，字符变量只能得到字符常量的最后 8 位。也就是说，以下代码
char ch = 'good';
ch 得到的是 &d& 的值。
4.不可打印字符（Nonprinting Characters）
有些 ASCII 字符是不可打印的。例如退格、另起一行、警报等。C 语言提供了两种方法来表示这种不可打印字符。
第一种方法是使用 ASCII 编码。例如，ASCII 编码中，7 用于表示警报：
char beep = 7;
第二种方法是使用特殊符号序列，也就是所谓的转义字符escape sequences）。参见下表：（
转义字符 含义
\a 警报（ Alert (ANSI C) ）
\b 退格（Backspace）
\f 换页（Form feed）
换行（Newline）
回车（Carriage return）
\t 水平制表符（Horizontal tab）
\v 垂直制表符（Vertical tab）
\ 反斜杆（ Backslash () ）
\& 单引号（ Single quote (&) ）
\& 双引号（ Double quote (&) ）
\? 问号（ Question mark (?) ）
\0oo 八进制数（ Octal value (o 代表一个八进制数字) ）
\xhh 十六进制数（ Hexadecimal value (h 代表一个十六进制数字) ）
给变量赋值的时候，转义字符必须使用单引号引住。例如：
char nl = ' ';
下面我们详细学习每个转移字符的含义。
\a（警报）是 ANSI C89 添加的，用于产生可听或者可视的警报。\a 产生的效果取决于硬件。一般来说，输出 \a 会产生鸣响。但是在某些系统，输出 \a 不会产生任何效果，或者仅仅显示一个特殊字符。标准明确指出，\a 不应该改变当前活跃位置（active position）。所谓活跃位置，是指显示设备（显示器、打字机、打印机等等）显示下一个字符的位置。以显示器为例，活跃位置就是指光标所处的位置，输出 \a 不会导致光标移动位置。
\b、\f、 、 、\t，以及 \v 都是输出设备控制符。退格符（\b）使当前行的活跃位置后退一个位置。换页符（\f）使活跃位置跳到下一页的开端。注：换页符可用于控制打印机换页，但不会导致 PC 机的显示屏换页。换行符（ ）使活跃位置跳到下一行的开端。回车符 （ ） 使活跃位置返回当前行的开端。水平制表符（\t）使活跃位置移动若干个位置（通常是8个）。垂直制表符（\v）使活跃位置换若干行。注：\v可用于控制打印机换若干行，但是不会导致PC机的显示屏换行。 \、\&，以及 \& 使我们可以把 \，& 和 & 用作字符常量。如果要打印以下句子：&\ is called &backslash&.&
我们需要使用如下语句：
printf(&\&\\ is called \'backslash\'.\&&);
\0oo 和 \xhh 是ASCII码的两种特殊表示形式。如果想用八进制ASCII码表示字符，可以在八进制数前面加上 \ ，然后用单引号引起来。例如：
beep = '\007';
\007 代表 \a
打头的那些0可以省略，也就是说，写成 &\07& 或者 &\7& 都一样。无论有没有打头的0 ，7 都会被当成八进制数处理。
从 C89 开始，C提供了用十六进制表示字符常量的方法：在反斜杆后面写一个 x ，然后再写 1 到 3 个十六进制数字。例如：
nl = '\xa';
注意：使用ASCII码时，要注意区分数字4的ASCII码是52 ，&4& 代表字符 4 ，而不是数字4。此外，尽管 & & 和 &\xa& ，&\a& 和 &\007& 是等价的，但是我们应该尽可能使用 & & 和 &\a& ，而不要用 &\xa& 和 &\007& 。这是因为前者易懂、便于记忆，而且移植性更高。而后者只对使用ASCII码的系统有效。和数字字符。例如：字符
5. 字符输出
printf 函数使用 %c 表示输出字符。因为字符是以 1 字节整数的形式存取的，所以，如果使用 %d 的话，输出的会是整数。例如：
/* 这个程序输出字符以及字符的整数编码 */
int main(void)
printf(&Please enter a character. &);
scanf(&%c&, &ch);
/* 由用户输入一个字符 */
printf(&The code for %c is %d. &, ch, ch);
请各位自行编译执行此程序，查看其执行结果。输入字符后记得要按回车键。
printf 函数输出 ch 的值两次，第一次以字符的形式输出（因为格式限定符为 %c），第二次以十进制整数的形式输出（因为格式限定符是 %d）。注意：格式限定符只是用于指定数据的输出形式，而不是用来指定数据怎么存储。
6.字符类型的符号
某些编译器中，char 默认是有符号的（signed）。对于这类型的编译器来说，char 的表示范围通常是 -128 到 127 。而另外一些编译器中，char 默认是无符号的（unsigned）。对于这类型的编译器来说，char 的表示范围通常是 0 到 255 。一般来说，编译器的使用说明会注明它默认把 char 当作有符号的还是无符号的。
从 C89 开始，我们可以使用关键字 signed 和 unsigned 来修饰 char 。这么一来，无论编译器默认 char 是有符号的也好，无符号的也罢，我们都可以用 signed char 表示有符号 char ，也可以用 unsigned char 表示无符号 char 。
在C中，默认的基础数据类型均为signed，现在我们以char为例，说明(signed) char与unsigned char之间的区别。
首先在内存中，char与unsigned char没有什么不同，都是一个字节，唯一的区别是，char的最高位为符号位，因此char能表示-127~127,unsigned char没有符号位，因此能表示0~255，这个好理解，8个bit，最多256种情况，因此无论如何都能表示256个数字。在实际使用过程种有什么区别呢？主要是符号位，但是在普通的赋值，读写文件和网络字节流都没什么区别，反正就是一个字节，不管最高位是什么，最终的读取结果都一样，只是你怎么理解最高位而已，在屏幕上面的显示可能不一样。二者的最大区别是：但是我们却发现在表示byte时，都用unsigned char，这是为什么呢？首先我们通常意义上理解，byte没有什么符号位之说，更重要的是如果将byte的值赋给int，long等数据类型时，系统会做一些额外的工作。如果是char，那么系统认为最高位是符号位，而int可能是16或者32位，那么会对最高位进行扩展（注意，赋给unsigned int也会扩展）而如果是unsigned char，那么不会扩展。最高位若为0时，二者没有区别，若为1时，则有区别了。同理可以推导到其它的类型，比如short， unsigned short，等等。
具体可以通过下面的小例子看看其区别
void f(unsigned char v)
char c =
unsigned char uc =
unsigned int a = c, b =
int i = c, j =
printf(&----------------\n&);
printf(&%%c: %c, %c\n&, c, uc);
printf(&%%X: %X, %X\n&, c, uc);
printf(&%%u: %u, %u\n&, a, b);
printf(&%%d: %d, %d\n&, i, j);
int main(int argc, char *argv[])
f(0x80);
f(0x7F);
return 0;
结果输出如下：
结果分析：
对于(signed)char来说，0x80用二进制表示为，当它作为char赋值给unsigned int或 int 时，系统认为最高位是符号位，会对最高位进行扩展。而0x7F用二进制表示为，最高位为0，不会扩展。对于unsigned char来说，不管最高位是0，还是1，都不会做扩展。
extern：声明变量是在其他文件正声明（也可以看做是引用变量）
extern可置于变量或者函数前，以表示变量或者函数的定义在别的文件中，提示编译器遇到此变量或函数时，在其它模块中寻找其定义。另外，extern也可用来进行链接指定。
在一个源文件里定义了一个https://blog.csdn.net/a193314/article/details/数组：char a[6];
在另外一个文件里用下列语句进行了声明：extern char *a；
请问，这样可以吗？
答案与分析：
1)、不可以，程序运行时会告诉你非法访问。原因在于，指向类型T的指针并不等价于类型T的https://blog.csdn.net/a193314/article/details/数组。extern char *a声明的是一个指针变量而不是字符https://blog.csdn.net/a193314/article/details/数组，因此与实际的定义不同，从而造成运行时非法访问。应该将声明改为extern char a[ ]。
2)、例子分析如下，如果a[] = &abcd&,则外部变量a=0x (https://blog.csdn.net/a193314/article/details/数组的起始地址)，而*a是重新定义了一个指针变量，a指向的地址可能是0x,直接使用*a是错误的.
3)、这提示我们，在使用extern时候要严格对应声明时的格式，在实际编程中，这样的错误屡见不鲜。
4)、extern用在变量声明中常常有这样一个作用：你要在.c文件中引用另一个文件中的一个全局的变量，那就应该放在.h中用extern来声明这个全局变量。
这个关键字真的比较可恶，在定义（函数）的时候，这个extern居然可以被省略，所以会让你搞不清楚到底是声明还是定义，下面分变量和函数两类来说：
尤其是对于变量来说。
//声明一个全局变量a
//定义一个全局变量a
extern int a =0 ;//定义一个全局变量a 并给初值。
//一旦给予赋值，一定是定义，定义才会分配存储空间。
int a =0;//定义一个全局变量a,并给初值，
声明之后你不能直接使用这个变量，需要定义之后才能使用。
第四个等于第三个，都是定义一个可以被外部使用的全局变量，并给初值。
糊涂了吧，他们看上去可真像。但是定义只能出现在一处。也就是说，不管是还是int a=0;都只能出现一次，而那个extern int a可以出现很多次。
当你要引用一个全局变量的时候，你就要声明这时候extern不能省略，因为省略了，就变成这是一个定义，不是声明。
常见extern放在函数的前面成为函数声明的一部分，那么，C语言的关键字extern在函数的声明中起什么作用？
答案与分析：
如果函数的声明中带有关键字extern，仅仅是暗示这个函数可能在别的源文件里定义，没有其它作用。即下述两个函数声明没有明显的区别：
extern int f(); 和int f();
当然，这样的用处还是有的，就是在程序中取代include &*.h&来声明函数，在一些复杂的项目中，我比较习惯在所有的函数声明前添加extern修饰。
extern函数2
当函数提供方单方面修改函数原型时，如果使用方不知情继续沿用原来的extern申明，这样编译时编译器不会报错。但是在运行过程中，因为少了或者多了输入参数，往往会造成系统错误，这种情况应该如何解决？
答案与分析：
目前业界针对这种情况的处理没有一个很完美的方案，通常的做法是提供放在自己的xxx_pub.h中提供对外部接口的声明，然后调用包涵该文件的头文件，从而省去extern这一步。以避免这种错误。
宝剑有双锋，对extern的应用，不同的场合应该选择不同的做法。
return ：子程序返回语句（可以带参数，也看不带参数）
比方主函数
int main（void）
这里就必须有一个return，只有void func()时可以不用返回值。
int fun（void）
return 1；
这个时候fun函数的作用就是返回一个int类型的值，可以直接拿来用
int a=fun（）；
这里就相当于int a=1；另外一个作用return后面的语句不会执行，我们可以用它来结束程序比方找出三个数种最大的一个数
void main（void）
int a，b，c；
return printf(&最大值为%d&，a);
在这里if（b&c）我们就可以直接得出a是最大了，就没必要执行下面的语句了，return。这里就起到了终止语句的作用了
int f(int a)
return -1;
else if(a==0)
int b=f(c);
c的值不同函数返回，给b值也就不同，我认为返回值是函数与外界的接口之一，至于所谓的状态应该是由人来规定的比如当返回值为0我们就知道f()的传入值c是等于0
的至于是return值还是return表达式都是一个意思因为表达式最终的值也是由表达式计算的最终结果来存储的返回值就是&函数值&学习C的时候天天都会遇到函数，而函数给一个自变量函数就会有一个函数值对吧.比如说正弦函数sin，sin(x)，不同的x值会得到不同的正弦值y=sin(x)就是将函数值赋值给y，函数运算完毕y就有了一个值c语言函数意思一样的
int f（int x)
return 2*x;
//函数返回值为x的2倍
int a=f(5)；
那么a是多少呢,就是2*5=10
return的作用是结束正在运行的函数，并返回函数值。return后面可以跟一个常量，变量，或是表达式。
函数的定义一般是这样的，例如：
int a（int
/*第一个int是函数的返回值的类型，也就是return后面跟的值的型，a是函数的称，括号里的是传递给函数的参数，int是参数的类型，i是参数的名字*/
...//省略函数体内容
//b必须与函数头的返回值一致（此处为int型）
简单函数举例：
int addOne(int b)
return b+1;
该函数的作用是取得一个数，将这个数加上1，再将结果返回
调用时这样：
int result=addOne（2）；//此时result的值为3
函数括号里的参数也可以为变量或能算出值的表达式
以上就是一个基本的函数，一般的函数都有返回值，也就是return后面跟的值，返回值可以为各种数据类型，如：int，float，double，char，a，*a（指针），结构或类（c++）但不是所有函数都有返回值，如果某个函数无返回值，那么返回值的位置则为&void&关键字，此时函数体中无返回值，即无return的值。
但是函数中也可出现return，即一个空的return句子，其作用是使函数立即结束，如
void print（）
//括号中为空表示无传递参数
printf(&a&);
printf(&b&);
//函数执行到此处结束
printf(&c&);
}//该函数只执行到return语句处，即屏幕上输出的为&ab&
union：声明联合数据类型
union 关键字的用法与struct 的用法非常类似。
union 维护足够的空间来置放多个数据成员中的&一种&，而不是为每一个数据成员配置空间，在union 中所有的数据成员共用一个空间，同一时间只能储存其中一个数据成员，所有的数据成员具有相同的起始地址。例子如下：
union StateMachine
一个union 只配置一个足够大的空间以来容纳最大长度的数据成员，以上例而言，最大长度是double 型态，所以StateMachine 的空间大小就是double 数据类型的大小。
在C++里，union 的成员默认属性页为public。union 主要用来压缩空间。如果一些数据不可能在同一时间同时被用到，则可以使用union。
一、大小端模式对union 类型数据的影响
下面再看一个例子：
char a[2];
p-&a[0] = 0x39;
p-&a[1] = 0x38;
p.i 的值应该为多少呢？
这里需要考虑存储模式：大端模式和小端模式。
大端模式（Big_endian）：字数据的高字节存储在低地址中，而字数据的低字节则存放在高地址中。
小端模式（Little_endian）：字数据的高字节存储在高地址中，而字数据的低字节则存放在低地址中。
union 型数据所占的空间等于其最大的成员所占的空间。对union 型的成员的存取都是相对于该联合体基地址的偏移量为0 处开始，也就是联合体的访问不论对哪个变量的存取都是从union 的首地址位置开始。如此一解释，上面的问题是否已经有了答案呢？
二、如何用程序确认当前系统的存储模式？
上述问题似乎还比较简单，那来个有技术含量的：请写一个C 函数，若处理器是Big_endian 的，则返回0；若是Little_endian 的，则返回1。
先分析一下，按照上面关于大小端模式的定义，假设int 类型变量i 被初始化为1。
以大端模式存储，其内存布局如下图：
以小端模式存储，其内存布局如下图：
变量i 占4 个字节，但只有一个字节的值为1，另外三个字节的值都为0。如果取出低地址上的值为0，毫无疑问，这是大端模式；如果取出低地址上的值为1，毫无疑问，这是小端模式。既然如此，我们完全可以利用union 类型数据的特点：所有成员的起始地址一致。vcD4NCjxwPrW9z9bU2qOs06a4w9aqtcDU9cO00LTBy7DJo7+yzr+8tPCwuMjnz8KjujwvcD4NCjxwcmUgY2xhc3M9"brush:">
int checkSystem( )
union check
return (c.ch ==1);
现在你可以用这个函数来测试你当前系统的存储模式了。当然你也可以不用函数而直接去查看内存来确定当前系统的存储模式。如下图：
图中0x01 的值存在低地址上，说明当前系统为小端模式。
不过要说明的一点是，某些系统可能同时支持这两种存储模式，你可以用硬件跳线或在编译器的选项中设置其存储模式。
留个问题：在x86 系统下，输出的值为多少？
int a[5]={1,2,3,4,5};
int *ptr1=(int *)(&a+1);
int *ptr2=(int *)((int)a+1);
printf(&%x,%x&,ptr1[-1],*ptr2);
const ：声明只读变量
const在C语言中算是一个比较新的描述符，我们称之为常量修饰符，意即其所修饰
的对象为常量(immutable)。
我们来分情况看语法上它该如何被使用。
1、函数体内修饰局部变量。
void func()
const int a=0;
首先，我们先把const这个单词忽略不看，那么a是一个int类型的局部自动变量，
我们给它赋予初始值0。然后再看const.const作为一个类型限定词，和int有相同的地位。
是等价的。于是此处我们一定要清晰的明白，const修饰的对象是谁，是a,和int没有关系。const 要求他所修饰的对象为常量，不可被改变，不可被赋值，不可作为左值（l-value)。
这样的写法也是错误的。
这是一个很常见的使用方式：
const double pi=3.14;
在程序的后面如果企图对pi再次赋值或者修改就会出错。
然后看一个稍微复杂的例子。
const int*
还是先去掉const 修饰符号。
注意，下面两个是等价的。
其实我们想要说的是，*p是int类型。那么显然，p就是指向int的指针。
const int*
其实等价于
const int (*p);
int const (*p);
即，*p是常量。也就是说，p指向的数据是常量。
p+=8; //合法
*p=3; //非法，p指向的数据是常量。
那么如何声明一个自身是常量指针呢？方法是让const尽可能的靠近p;
const右面只有p,显然，它修饰的是p,说明p不可被更改。然后把const去掉，可以
看出p是一个指向 int形式变量的指针。
p+=8; //非法
*p=3; //合法
再看一个更复杂的例子，它是上面二者的综合
const int*
说明p自己是常量，且p指向的变量也是常量。
p+=8; //非法
*p=3; //非法
const 还有一个作用就是用于修饰常量静态字符串。
const char* name=D
如果没有const,我们可能会在后面有意无意的写name[4]=&x&这样的语句，这样会
导致对只读内存区域的赋值，然后程序会立刻异常终止。有了 const,这个错误就
能在程序被编译的时候就立即检查出来，这就是const的好处。让逻辑错误在编译
期被发现。
const 还可以用来修饰https://blog.csdn.net/a193314/article/details/数组
const char s[]=D
与上面有类似的作用。
2、在函数声明时修饰参数
来看实际中的一个例子。
void *memmove(void *dst, const void *src, size_t len);
这是标准库中的一个函数，用于按字节方式复制字符串（内存）。
它的第一个参数，是将字符串复制到哪里去（dest),是目的地，这段内存区域必须
是可写。它的第二个参数，是要将什么样的字符串复制出去，我们对这段内存区域只做读取，不写。于是，我们站在这个函数自己的角度来看，src 这个指针，它所指向的内存内所存储的数据在整个函数执行的过程中是不变。于是src所指向的内容是常量。于是就需要用const修饰。
例如，我们这里这样使用它。
const char* s=
char buf[100];
memmove(buf,s,6); //这里其实应该用strcpy或memcpy更好
如果我们反过来写，
memmove(s,buf,6);
那么编译器一定会报错。事实是我们经常会把各种函数的参数顺序写反。事实是编
译器在此时帮了我们大忙。如果编译器静悄悄的不报错，(在函数声明处去掉
const即可),那么这个程序在运行的时候一定会崩溃。
这里还要说明的一点是在函数参数声明中const一般用来声明指针而不是变量本身。
例如，上面的size_t len,在函数实现的时候可以完全不用更改len的值，那么是否
应该把len也声明为常量呢？可以，可以这么做。我们来分析这么做有什么优劣。
如果加了const,那么对于这个函数的实现者，可以防止他在实现这个函数的时候修
改不需要修改的值(len),这样很好。
但是对于这个函数的使用者，
1。这个修饰符号毫无意义，我们可以传递一个常量整数或者一个非常量整数过
去，反正对方获得的只是我们传递的一个copy。
2。暴露了实现。我不需要知道你在实现这个函数的时候是否修改过len的值。
所以，const一般只用来修饰指针。
再看一个复杂的例子
int execv(const char *path, char *const argv[]);
着重看后面这个，argv.它代表什么。
如果去掉const,我们可以看出
char * argv[];
argv是一个https://blog.csdn.net/a193314/article/details/数组，它的每个元素都是char *类型的指针。
如果加上const.那么const修饰的是谁呢？他修饰的是一个https://blog.csdn.net/a193314/article/details/数组，argv[],意思就是
说这个https://blog.csdn.net/a193314/article/details/数组的元素是只读的。那么https://blog.csdn.net/a193314/article/details/数组的元素的是什么类型呢？是char *类型的指
针.也就是说指针是常量，而它指向的数据不是。
argv[1]=NULL; //非法
argv[0][0]='a'; //合法
3、全局变量。
我们的原则依然是，尽可能少的使用全局变量。我们的第二条规则 则是，尽可能多的使用const。如果一个全局变量只在本文件中使用，那么用法和前面所说的函数局部变量没有什么区别。如果它要在多个文件间共享，那么就牵扯到一个存储类型的问题。有两种方式。
1.使用extern
/* file1.h */
/* file1.c */
const double pi=3.14;
然后其他需要使用pi这个变量的，包含file1.h
#include file1.h
或者，自己把那句声明复制一遍就好。这样做的结果是，整个程序链接完后，所有需要使用pi这个变量的共享一个存储区域。
2.使用static,静态外部存储类
/* constant.h */
static const pi=3.14;
需要使用这个变量的*.c文件中，必须包含这个头文件。
前面的static一定不能少。否则链接的时候会报告说该变量被多次定义。
这样做的结果是，每个包含了constant.h的*.c文件，都有一份该变量自己的copy,
该变量实际上还是被定义了多次，占用了多个存储空间，不过在加了static关键字
后，解决了文件间重定义的冲突。
坏处是浪费了存储空间，导致链接完后的可执行文件变大。但是通常，这个，小小
几字节的变化，不是问题。
好处是，你不用关心这个变量是在哪个文件中被初始化的。
最后，说说const的作用。
const 的好处，是引入了常量的概念，让我们不要去修改不该修改的内存。直接的
作用就是让更多的逻辑错误在编译期被发现。所以我们要尽可能的多使用const。
但是很多人并不习惯使用它，更有甚者，是在整个程序 编写／调试 完后才补
const。如果是给函数的声明补const,尚好。如果是给 全局／局部变量补const,那
么&&那么，为时已晚，无非是让代码看起来更漂亮了。
float：声明浮点型变量或函数
浮点数使用 IEEE（电气和电子工程师协会）格式。浮点类型的单精度值具有 4 个字节，包括一个符号位、一个 8 位 excess-127 二进制指数和一个 23 位尾数。尾数表示一个介于 1.0 和 2.0 之间的数。由于尾数的高顺序位始终为 1，因此它不是以数字形式存储的。此表示形式为 float 类型提供了一个大约在 3.4E&38 和 3.4E+38 之间的范围。
您可根据应用程序的需求将变量声明为 float 或 double。这两种类型之间的主要差异在于它们可表示的基数、它们需要的存储以及它们的范围。下表显示了基数与存储需求之间的关系。
浮点变量由尾数（包含数字的值）和指数（包含数字的数量级）表示。
下表显示了分配给每个浮点类型的尾数和指数的位数。任何 float 或 double 的最高有效位始终是符号位。如果符号位为 1，则将数字视为负数；否则，将数字视为正数。
指数和尾数的长度
由于指数是以无符号形式存储的，因此指数的偏差为其可能值的一半。对于 float 类型，偏差为 127；对于 double 类型，偏差为 1023。您可以通过将指数值减去偏差值来计算实际指数值。
存储为二进制分数的尾数大于或等于 1 且小于 2。对于 float 和 double 类型，最高有效位位置的尾数中有一个隐含的前导 1，这样，尾数实际上分别为 24 和 53 位长，即使最高有效位从未存储在内存中也是如此。
浮点包可以将二进制浮点数存储为非标准化数，而不使用刚刚介绍的存储方法。&非标准化数&是带有保留指数值的非零浮点数，其中尾数的最高有效位为 0。通过使用非标准化格式，浮点数的范围可以扩展，但会失去精度。您无法控制浮点数以标准化形式还是非标准化形式表示；浮点包决定了表示形式。浮点包从不使用非标准化形式，除非指数变为小于可以标准化形式表示的最小值。
下表显示了可在每种浮点类型的变量中存储的最小值和最大值。此表中所列的值仅适用于标准化浮点数；非标准化浮点数的最小值更小。请注意，在 80x87 寄存器中保留的数字始终以 80 位标准化形式表示；数字存储在 32 位或 64 位浮点变量（float 类型和 long 类型的变量）中时只能以非标准化形式表示。
浮点类型的范围
如果存储比精度更重要，请考虑对浮点变量使用 float 类型。相反，如果精度是最重要的条件，则使用 double 类型。
浮点变量可以提升为更大基数的类型（从 float 类型到 double 类型）。当您对浮点变量执行算术时，通常会出现提升。此算术始终以与具有最高精度的变量一样高的精度执行。例如，请考虑下列类型声明：
long double f_
f_short = f_short * f_
在前面的示例中，变量 f_short 提升到类型 double 并且与 f_long 相乘；然后，结果舍入到类型 float，然后赋给 f_short。
在以下示例中（使用前面示例中的声明），将以浮点（32 位）精度对变量执行算术；结果随后将提升到 double 类型：
f_longer = f_short * f_
short ：声明短整型变量或函数
C语言中，short是定义一种整型变量家族的一种。例如short i；表示定义一个短整型的变量i。
依据程序编译器的不同short定义的字节数不同。
标准定义short短整型变量不得低于16位，即两个字节。
unsigned， signed：声明无符号类型变量或函数
所有的整型类型都有两种变体：signed 和 unsigned。 有时候，要求整型变量能够存储负数，有时候则不要求。
没有使用关键字unsigned生命的整型变量都被视为无符号的，这种变量可以为正，也可以为负；而unsigned整型变量只能为正
signed 和 unsigned 整型变量占用的内存空间大小相同，而signed整型变量的部分存储空间被用于存储指出该变量是为正还是为负的信息，
因此unsigned整型变量能存储的最大值为signed整型变量能够存储的最大正数的两倍
例如，如果short变量占用2字节，则unsigned short变量的取值范围是0 - 65535，而signed short变量的取值范围内一般为正数，即最大正数为32767，然后，signed short变量也能存储负数，因此其取值范围为-32768 - 32767
continue：结束当前循环，开始下一轮循环
continue语句的作用是跳过循环体中剩余的语句而强行执行下一次循环。continue语句只用在for、while、do-while等循环体中，常与if条件语句一起使用，用来加速循环。
对比一下break和continue。
while的用法：
while(表达式1){
if(表达式2)
continue的用法：
while(表达式1){
if(表达式2)
int main(void)
while(c!=13){
/*不是回车符则循环*/
c=getch();
if(c==0X1B)
/*若按Esc键不输出便进行下次循环*/
printf(&%c\n&, c);
for：一种循环语句(可意会不可言传）
for(i=0;i&10
void ：声明函数无返回值或无参数，声明无类型指针（基本上就这三个作用）
goto：无条件跳转语句
int main(void)
int err=-1;
err=func();
return -1;
sizeof：计算数据类型长度
int main(void)
printf(&%d\n&,sizeof(int));//注意sizeof 计算数据类型的大小
volatile：说明变量在程序执行中可被隐含地改变
volatile提醒编译器它后面所定义的变量随时都有可能改变，因此编译后的程序每次需要存储或读取这个变量的时候，都会直接从变量地址中读取数据。如果没有volatile关键字，则编译器可能优化读取和存储，可能暂时使用寄存器中的值，如果这个变量由别的程序更新了的话，将出现不一致的现象。下面举例说明。在DSP开发中，经常需要等待某个事件的触发，所以经常会写出这样的程序：
void test()
while(flag==0);
这段程序等待内存变量flag的值变为1(怀疑此处是0,有点疑问,)之后才运行do2()。变量flag的值由别的程序更改，这个程序可能是某个硬件中断服务程序。例如：如果某个按钮按下的话，就会对DSP产生中断，在按键中断程序中修改flag为1，这样上面的程序就能够得以继续运行。但是，编译器并不知道flag的值会被别的程序修改，因此在它进行优化的时候，可能会把flag的值先读入某个寄存器，然后等待那个寄存器变为1。如果不幸进行了这样的优化，那么while循环就变成了死循环，因为寄存器的内容不可能被中断服务程序修改。为了让程序每次都读取真正flag变量的值，就需要定义为如下形式：
需要注意的是，没有volatile也可能能正常运行，但是可能修改了编译器的优化级别之后就又不能正常运行了。因此经常会出现debug版本正常，但是release版本却不能正常的问题。所以为了安全起见，只要是等待别的程序修改某个变量的话，就加上volatile关键字。
volatile的本意是&易变的&
由于访问寄存器的速度要快过RAM，所以编译器一般都会作减少存取外部RAM的优化。比如：
static int i=0;
int main(void)
do_something();
/* Interrupt service routine. */
void ISR_2(void)
程序的本意是希望ISR_2中断产生时，在main当中调用do_something函数，但是，由于编译器判断在main函数里面没有修改过i，因此可能只执行一次对从i到某寄存器的读操作，然后每次if判断都只使用这个寄存器里面的&i副本&，导致do_something永远也不会被调用。如果变量加上volatile修饰，则编译器保证对此变量的读写操作都不会被优化（肯定执行）。此例中i也应该如此说明。
一般说来，volatile用在如下的几个地方：
1、中断服务程序中修改的供其它程序检测的变量需要加volatile；
2、多任务环境下各任务间共享的标志应该加volatile；
3、存储器映射的硬件寄存器通常也要加volatile说明，因为每次对它的读写都可能由不同意义；
另外，以上这几种情况经常还要同时考虑数据的完整性（相互关联的几个标志读了一半被打断了重写），在1中可以通过关中断来实现，2中可以禁止任务调度，3中则只能依靠硬件的良好设计了。
二、volatile 的含义
volatile总是与优化有关，编译器有一种技术叫做数据流分析，分析程序中的变量在哪里赋值、在哪里使用、在哪里失效，分析结果可以用于常量合并，常量传播等优化，进一步可以死代码消除。但有时这些优化不是程序所需要的，这时可以用volatile关键字禁止做这些优化，volatile的字面含义是易变的，它有下面的作用：
1 不会在两个操作之间把volatile变量缓存在寄存器中。在多任务、中断、甚至setjmp环境下，变量可能被其他的程序改变，编译器自己无法知道，volatile就是告诉编译器这种情况。
2 不做常量合并、常量传播等优化，所以像下面的代码：
volatile int i = 1;
if (i & 0) &
if的条件不会当作无条件真。
3 对volatile变量的读写不会被优化掉。如果你对一个变量赋值但后面没用到，编译器常常可以省略那个赋值操作，然而对Memory Mapped IO的处理是不能这样优化的。
前面有人说volatile可以保证对内存操作的原子性，这种说法不大准确，其一，x86需要LOCK前缀才能在SMP下保证原子性，其二，RISC根本不能对内存直接运算，要保证原子性得用别的方法，如atomic_inc。
对于jiffies，它已经声明为volatile变量，我认为直接用jiffies++就可以了，没必要用那种复杂的形式，因为那样也不能保证原子性。
你可能不知道在Pentium及后续CPU中，下面两组指令
inc jiffies
mov jiffies, %eax
mov %eax, jiffies
作用相同，但一条指令反而不如三条指令快。
三、编译器优化 & C关键字volatile & memory破坏描述符zz
&memory&比较特殊，可能是内嵌汇编中最难懂部分。为解释清楚它，先介绍一下编译器的优化知识，再看C关键字volatile。最后去看该描述符。
1、编译器优化介绍
内存访问速度远不及CPU处理速度，为提高机器整体性能，在硬件上引入硬件高速缓存Cache，加速对内存的访问。另外在现代CPU中指令的执行并不一定严格按照顺序执行，没有相关性的指令可以乱序执行，以充分利用CPU的指令流水线，提高执行速度。以上是硬件级别的优化。再看软件一级的优化：一种是在编写代码时由程序员优化，另一种是由编译器进行优化。编译器优化常用的方法有：将内存变量缓存到寄存器；调整指令顺序充分利用CPU指令流水线，常见的是重新排序读写指令。对常规内存进行优化的时候，这些优化是透明的，而且效率很好。由编译器优化或者硬件重新排序引起的问题的解决办法是在从硬件（或者其他处理器）的角度看必须以特定顺序执行的操作之间设置内存屏障（memory barrier），linux 提供了一个宏解决编译器的执行顺序问题。
void Barrier(void)
这个函数通知编译器插入一个内存屏障，但对硬件无效，编译后的代码会把当前CPU寄存器中的所有修改过的数值存入内存，需要这些数据的时候再重新从内存中读出。
2、C语言关键字volatile
C语言关键字volatile（注意它是用来修饰变量而不是上面介绍的volatile）表明某个变量的值可能在外部被改变，因此对这些变量的存取不能缓存到寄存器，每次使用时需要重新存取。该关键字在多线程环境下经常使用，因为在编写多线程的程序时，同一个变量可能被多个线程修改，而程序通过该变量同步各个线程，例如：
DWORD __stdcall threadFunc(LPVOID signal)
int* intSignal=reinterpret_cast(signal);
*intSignal=2;
while(*intSignal!=1)
sleep(1000);
该线程启动时将intSignal 置为2，然后循环等待直到intSignal 为1 时退出。显然intSignal的值必须在外部被改变，否则该线程不会退出。但是实际运行的时候该线程却不会退出，即使在外部将它的值改为1，看一下对应的伪汇编代码就明白了：
mov ax,signal
goto label
对于C编译器来说，它并不知道这个值会被其他线程修改。自然就把它cache在寄存器里面。记住，C 编译器是没有线程概念的！这时候就需要用到volatile。volatile 的本意是指：这个值可能会在当前线程外部被改变。也就是说，我们要在threadFunc中的intSignal前面加上volatile关键字，这时候，编译器知道该变量的值会在外部改变，因此每次访问该变量时会重新读取，所作的循环变为如下面伪码所示：
mov ax,signal
goto label
有了上面的知识就不难理解Memory修改描述符了，Memory描述符告知GCC：
1）不要将该段内嵌汇编指令与前面的指令重新排序；也就是在执行内嵌汇编代码之前，它前面的指令都执行完毕
2）不要将变量缓存到寄存器，因为这段代码可能会用到内存变量，而这些内存变量会以不可预知的方式发生改变，因此GCC插入必要的代码先将缓存到寄存器的变量值写回内存，如果后面又访问这些变量，需要重新访问内存。
如果汇编指令修改了内存，但是GCC 本身却察觉不到，因为在输出部分没有描述，此时就需要在修改描述部分增加&memory&，告诉GCC 内存已经被修改，GCC 得知这个信息后，就会在这段指令之前，插入必要的指令将前面因为优化Cache 到寄存器中的变量值先写回内存，如果以后又要使用这些变量再重新读取。
使用&volatile&也可以达到这个目的，但是我们在每个变量前增加该关键字，不如使用&memory&方便。
do while ：循环语句的循环条件
do-while语句的一般形式为：
while(表达式);
这个循环与while循环的不同在于：它先执行循环中的语句，然后再判断表达式是否为真，如果为真则继续循环；如果为假，则终止循环。因此，do-while循环至少要执行一次循环语句。其执行过程可用下图表示。
//用do-while语句计算从1加到100的值
int main(void)
int i,sum=0;
sum=sum+i;
while(i&=100);
printf(&%d\n&,sum);
//while和do-while循环比较。
//while循环：
int main(void)
int sum=0,i;
scanf(&%d&,&i);
while(i&=10)
sum=sum+i;
printf(&sum=%d&,sum);
//do-while循环
int main(void)
int sum=0,i;
scanf(&%d&,&i);
sum=sum+i;
while(i&=10);
printf(&sum=%d&,sum);
static ：声明静态变量
在C语言中，static的字面意思很容易把我们导入歧途，其实它的作用有三条。
（1）先来介绍它的第一条也是最重要的一条：隐藏。
当我们同时编译多个文件时，所有未加static前缀的全局变量和函数都具有全局可见性。为理解这句话，我举例来说明。我们要同时编译两个源文件，一个是a.c，另一个是main.c。
下面是a.c的内容
char a = 'A'; // global variable
void msg()
printf(&Hello\n&);
下面是main.c的内容
int main(void)
// extern variable must be declared before use
printf(&%c &, a);
(void)msg();
程序的运行结果是：
你可能会问：为什么在a.c中定义的全局变量a和函数msg能在main.c中使用？前面说过，所有未加static前缀的全局变量和函数都具有全局可见性，其它的源文件也能访问。此例中，a是全局变量，msg是函数，并且都没有加static前缀，因此对于另外的源文件main.c是可见的。
如果加了static，就会对其它源文件隐藏。例如在a和msg的定义前加上static，main.c就看不到它们了。利用这一特性可以在不同的文件中定义同名函数和同名变量，而不必担心命名冲突。Static可以用作函数和变量的前缀，对于函数来讲，static的作用仅限于隐藏，而对于变量，static还有下面两个作用。
（2）static的第二个作用是保持变量内容的持久。存储在静态数据区的变量会在程序刚开始运行时就完成初始化，也是唯一的一次初始化。共有两种变量存储在静态存储区：全局变量和static变量，只不过和全局变量比起来，static可以控制变量的可见范围，说到底static还是用来隐藏的。虽然这种用法不常见，但我还是举一个例子。
int fun(void){
static int count = 10;
// 事实上此赋值语句从来没有执行过
return count--;
int count = 1;
int main(void)
printf(&global\t\tlocal static\n&);
for(; count &= 10; ++count)
printf(&%d\t\t%d\n&, count, fun());
程序的运行结果是：
global local static
（3）static的第三个作用是默认初始化为0。其实全局变量也具备这一属性，因为全局变量也存储在静态数据区。在静态数据区，内存中所有的字节默认值都是0x00，某些时候这一特点可以减少程序员的工作量。比如初始化一个稀疏矩阵，我们可以一个一个地把所有元素都置0，然后把不是0的几个元素赋值。如果定义成静态的，就省去了一开始置0的操作。再比如要把一个字符https://blog.csdn.net/a193314/article/details/数组当字符串来用，但又觉得每次在字符https://blog.csdn.net/a193314/article/details/数组末尾加&\0&太麻烦。如果把字符串定义成静态的，就省去了这个麻烦，因为那里本来就是&\0&。不妨做个小实验验证一下。
int main(void)
static char str[10];
printf(&integer: %d;
string: (begin)%s(end)&, a, str);
程序的运行结果如下
integer: 0; string: (begin)(end)
最后对static的三条作用做一句话总结。首先static的最主要功能是隐藏，其次因为static变量存放在静态存储区，所以它具备持久性和默认值0。
下面是中兴通讯2012校招笔试题的一道问答题：
1. static全局变量与普通的全局变量有什么区别 ?
全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。
全局变量本身就是静态存储方式， 静态全局变量当然也是静态存储方式。 这两者在存储方式上并无不同。
这两者的区别在于非静态全局变量的作用域是整个源程序， 当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。 而静态全局变量则限制了其作用域， 即只在定义该变量的源文件内有效， 在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，因此可以避免在其它源文件中引起错误。
static全局变量只初使化一次，防止在其他文件单元中被引用;
2. static局部变量和普通局部变量有什么区别 ？
把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域，限制了它的使用范围。
static局部变量只被初始化一次，下一次依据上一次结果值；
3. static函数与普通函数有什么区别？
static函数与普通函数作用域不同,仅在本文件。只在当前源文件中使用的函数应该说明为内部函数(static修饰的函数)，内部函数应该在当前源文件中说明和定义。对于可在当前源文件以外使用的函数，应该在一个头文件中说明，要使用这些函数的源文件要包含这个头文件.
static函数在内存中只有一份，普通函数在每个被调用中维持一份拷贝
