1、auto
修饰局部变量，编译器默认所有局部变量都是用auto来修饰的，所以在程序中很少见到。
2、static
它作用可大了，除了可以修饰变量，还可以修饰函数，修饰变量，改变其作用域和生命周期，修饰函数，改变作用域。
（1）修饰变量：如果该变量是局部变量，那么生命周期会变化，作用域限定在本文件中被使用，如果该变量是全局变量，生命周期没变化，作用域限定在本文件中被使用。
（2）修饰函数：该函数只能在当前文件下被调用。
3、register
（1）寄存器变量的处理速度是最快的，适合频繁使用的变量。
（2）寄存器变量时没有地址的，不能用取地址的方式访问。
（3）寄存器变量不能用来做全局变量，因为全局变量的生命周期很长，贯穿整个运行周期，这样CPU的内存一直被占据，影响运行的效率，甚至会影响CPU的运行，一般定义全局寄存器变量编译器会直接报错。
void test(void)
{
register Val=;
printf("%d\n", Val);
}
PS:上面3个可以放到一组，因为它们有共同的特点，都决定变量的属性。C语言中的变量是有属性的，auto属性的变量存储在栈中，static属性的变量存储在程序静态区中（解释了为什么用static修饰的局部变量生命周期和静态区的变量一样长），register属性的变量存储在CPU的寄存器中。
4、extern
它的作用就是声明变量或者函数，本来应该和static放到一组，因为它也修饰变量和函数。
（1）修饰变量：只能修饰全局变量，生命周期没变化，作用域延伸到其他文件。
（2）修饰函数：一般不用写出来，和auto类似。
（3）一般写在头文件中，然后文件用到时直接调用头文件。
5、if
if语句中的零值比较总结：
（1）bool型变量
bool a;
if(a)
{
printf("ok");
}
else
{
printf("error");
}
C语言中是没有bool型变量的，但是很多编译器内置了bool型变量，所以有的时候能看到像上面一样在程序中直接写出来了。实际上，一般bool型变量通常是用枚举来定义的，完整的if语句中的零值比较的示例应该是：
typedef enum _bool
{
,
}bool;
bool a=ture;
if(a)
{
printf("ok");
}
else
{
printf("error");
}
（2）整形变量
int a;
==a)
{
printf("ok");
}
else
{
printf("error");
}
（3）浮点型变量
#define FLOAT 0.00000001
float a=0.0;
if((-FLOAT<=a)&&(a<=FLOAT))
{
printf("ok");
}
else
{
printf("error");
}
如果定义float a=5.0，相应的if语句修改为：if((5.0-FLOAT<=a) && (a<=5.0+FLOAT))。
6、switch
它是if语句的同胞兄弟，当有单个条件，多个分值时，一般用switch。
PS:上面两个可以放到一组，都是分支语句。从功能上讲，if可以代替switch语句，但是，switch不能代替if语句。
7、break
既能用于循环语句，又能用于分支语句，表示终止整个循环。
8、continue
只能用于循环语句，不能用于分支语句，表示终止本次循环，进入下次循环。
//示例：从键盘输入3个数，求其中非负数之和
void test()
{
,sum=;
)
{
scanf("%d",&input);
count++;
) continue;
sum+=input;
}
printf("%d\n",sum);
}
PS:这两个可以放到一组，相同点是都能跳出循环，不同点是程度不同。
9、do
循环语句，先执行，后判断，循环体至少执行一次。
10、while
循环语句，先判断，后执行，循环体可能不执行。
11、for
循环语句，先判断，后执行。
PS:这3个可以放到一组，都是循环语句。
//示例：求1到n的和
void test() //do
{
,sum=;
scanf("%d",&n);
)
{
do
{
sum=sum+n;
n--;
}while(n);
printf("the sum is %d\n",sum);
}
else
{
printf("please input a number greater than 1");
}
}
void test2() //while
{
,sum=;
scanf("%d",&n);
)
{
while(n)
{
sum=sum+n;
n--;
}
printf("the sum is %d\n",sum);
}
else
{
printf("please input a number greater than 1");
}
}
void test3() //for
{
,n=,sum=;
scanf("%d",&n);
)
{
;i--)
{
sum=sum+n;
n--;
}
printf("the sum is %d\n",sum);
}
else
{
printf("please input a number greater than 1");
}
}
12、sizeof
它是编译器内置的一个指示符，并不是一个函数，用于计算各个数据类型所占的内存大小。
（1）sizeof常用来计算数组长度，int a[]={1,2,3,4,5,6,7,8}; 数字长度就是：sizeof(a)/sizeof(a[0])
（2）sizeof与strlen的差别
#include<stdio.h>
#include<string.h>
int main()
{
char a[]="abcdefg";
printf("%d\n", sizeof(a)); //结果：8
printf("%d\n", strlen(a)); //结果：7
;
}
strlen是一个C库函数，用来返回一个字符串的长度（注意，字符串的长度是不计算字符串末尾的'\0'的）。strlen接收的参数必须是一个字符串（字符串的特征是以'\0'结尾）
sizeof是一个关键字，接收的参数是数据类型或者变量。
13、void
（1）void的作用：修饰函数的返回值和参数，如果一个函数没有返回值和参数，就用void声明。
（2）不允许有void类型的变量，但允许有void*类型的变量。当void*修饰变量时，void*类型变量作为左值用于接收任意类型的指针变量，void*类型变量作为右值赋给其他指针的时候需要进行强制类型装换。
（3）拓展：在学习线性表的时候，接触到了void*函数，里面用它进行数据封装，这也是产品级代码经常使用的方法。
PS：void用来修饰函数，void*用来修饰函数和变量。
14、scanf
scanf语句的作用是等待接收键盘上输入的数据，特点是阻塞式，只有当键盘输入相应的字符之后才能接着执行后面的语句。
15、printf
（1）作用：打印输出数据，做练习和调试的时候经常用到。
（2）printf中常用的格式符及含义
| 格式符 | 功能 |
| %d | 以带符号的10进制形式输出整数（正数不输出正号+） |
| %u | 以不带符号的10进制形式输出整数 |
| %o | 以不带符号的8进制形式输出整数 |
| %x | 以不带符号的16进制形式输出整数 |
| %c | 输出一个字符 |
| %s | 输出一个或者多个字符 |
| %f | 以小数形式输出单、双精度数，默认输出6位小数 |
| %e | 以标准指数形式输出单、双精度数，数字部分小数位数为6位 |
（3）printf函数的入栈问题
原则是先从右边至左计算，然后从左至右打印。理解下面的代码为什么是这个结果。
void test()
{
;
printf("%d %d %d\n",a++,a,a++); //2 3 1
}
void test2()
{
;
printf("%d %d %d\n",a++,a++,a++); //3 2 1
}
void test3()
{
;
printf("%d %d %d\n",a++,++a,a); //2 3 3
}
void test4()
{
int a;
a=;
printf("%d %d %d\n",a++,++a,a++); //3 4 1
printf("%d %d %d\n",a++,++a,a); //5 6 6
}
16、const
（1）首先弄清楚一点，在标准C中，const定义的不是一个常亮，它定义的是一个只读的变量。本质上只对编译器有用，告诉编译器这个变量不能作为左值，例如下面的代码编译时会报错。
void test()
{
;
printf("%d\n",cc);
cc=3; //函数会在这行报错，因为 cc用const修饰了,代表只读，不能作为左值。
printf("%d\n",cc);
}
（2）在上面讲到用const修饰的变量只对编译器有用，换句话说就是在运行时无用，还是可以同过指针修改变量的值。（const修饰数组与修饰变量类似）
void test2()
{
;
int *p=(int *) &cc; //注意强制类型转换
printf("%d\n",cc);
*p=;
printf("%d\n",cc);
}
（3）现代C编译器中的const将具有全局生命周期的变量存储于只读存储区，不客修改。
#include<stdio.h>
] = {};
void modify(int* p,int v)
{
*p = v;
}
int main()
{
;
;
] = {};
modify((); //ok
//modify((int*)&j,2); //运行崩溃
modify((],); //ok
//modify((int*)&g_array[0],4); //运行崩溃
printf("%d\n",i);
printf("%d\n",j);
printf(]);
printf(]);
;
}
（4）const修饰指针。要领：左数右指。当const出现在*的左边时，指针指向的数据不能改变，当const出现在*右边时，指针本身（指针指向的地址值）不能改变，当const出现在*的两边时，指针指向的数据和指针本身（指针指向的地址值）都不能改变。
17、volatile
（1）作用：编译器警告指示字--告诉编译器必须每次去内存中取变量值，不要做优化。
（2）理解：在C语言中，如果定义的变量没有被当做左值（都是出现在程序语句的右边）使用，编译器就会认为它的值不会被改变， “聪明”的对其优化（能加快程序运行效率），每次默认对它取所赋的右值。举个例子：
; ; ; a=result; delay(); b=result;
上面的代码这样写没问，但是在嵌入式系统中，如果延时的200ms里出现一个中断，要把result的值（内存中的值）改变为5，如果不加volatile修饰int result=1，系统优化后，b的值还会是1，就得不到我们预期的值，出现不可预计的错误。而加上volatile，表示每次都去内存中去取值，这样中断后我们就能得到预期的值。
（3）思考
思考一：const和volatile是否可以同时修饰一个变量？
能。关键搞清楚 编译期 和 运行期 的关系。编译期就是编译器将源代码转化为汇编再到机器代码的过程。运行期就是实际的机器代码在CPU执行的过程。const在编译的时候起作用，它告诉编译器它修饰的变量是只读的，不能而出现在赋值符号左边。实际运行的时候就不是编译器所能管的了。volatile在运行的时候起作用，保证其修饰的变量不被优化，每次每次读取它都会在内存中取值。
思考二：const volatile int i = 0; 这个时候i具有什么属性？编译器如何处理这个变量?
属性：在编译期，i是一个只读变量，不能而出现在赋值符号左边。在运行期，i不会被优化，每次读取它都会在内存中取值。
处理：如果i出现在赋值符号左边，编译报错。
18、struct
（1）结构体的出现时为了解决数组的不足之处，它是一种构造数据类型。结构体使用总结如下：
1.1 结构体初始化--分为完全初始化和部分初始化
//1.1 完全初始化--定义结构体的同时定义变量
#if 0
#include<stdio.h>
struct student{
char *name1;
];
int age;
char c; //定义一个字符
float height;
}stu={,'M',1.75};
//字符串常量初始化这一项会有警告，故实践中，完全初始化字符串时用数组的形式。
int main()
{
printf("姓名: %s\n",stu.name1);
printf("姓名: %s\n",stu.name2);
printf("年龄: %d\n",stu.age);
printf("age = %c\n",stu.c);
printf("身高: %.2f\n",stu.height);
;
}
#endif
//1.2 完全初始化--先定义结构体，再定义变量
#if 0
#include<stdio.h>
struct student{
char *name1;
];
int age;
char c; //定义一个字符
float height;
};
,'M',1.75};
//字符串常量初始化这一项会有警告，故实践中，完全初始化字符串时用数组的形式。
int main()
{
printf("姓名: %s\n",stu.name1);
printf("姓名: %s\n",stu.name2);
printf("年龄: %d\n",stu.age);
printf("age = %c\n",stu.c);
printf("身高: %.2f\n",stu.height);
;
}
#endif
//2.1 部分初始化--定义结构体的同时定义变量
#if 0
#include<stdio.h>
#include<string.h>
struct student
{
char *name1; //定义字符串常亮
]; //定义字符串变量
int age; //定义整形数
char c; //定义一个字符
float height; //定义一个浮点数
}stu;
int main()
{
stu.name1="pual"; //字符串常量初始化 --这样子初始化在结构体部分初始化中也会有警告，故实践中，部分初始化字符串时用数组的形式。
strcpy(stu.name2,"wade"); //字符串变量初始化
stu.age=; //整形数初始化
stu.c='m'; //字符初始化
stu.height=1.72; //浮点数初始化
printf("姓名: %s\n",stu.name1);
printf("姓名: %s\n",stu.name2);
printf("age = %d\n",stu.age);
printf("age = %c\n",stu.c);
printf(" %.2f\n",stu.height);
;
}
#endif
//2.2 部分初始化--先定义结构体，再定义变量
#if 1
#include<stdio.h>
#include<string.h>
struct student
{
char *name1; //定义字符串常亮
]; //定义字符串变量
int age; //定义整形数
char c; //定义一个字符
float height; //定义一个浮点数
};
struct student stu;
int main()
{
stu.name1="pual"; //字符串常量初始化 --这样子初始化在结构体部分初始化中也会有警告，故实践中，部分初始化字符串时用数组的形式。
strcpy(stu.name2,"wade"); //字符串变量初始化
stu.age=; //整形数初始化
stu.c='m'; //字符初始化
stu.height=1.72; //浮点数初始化
printf("姓名: %s\n",stu.name1);
printf("姓名: %s\n",stu.name2);
printf("age = %d\n",stu.age);
printf("age = %c\n",stu.c);
printf(" %.2f\n",stu.height);
;
}
#endif
/*“特别注意”： stu.name="abc";
stu.age=15;
stu.height=1.72;
这些部分初始化要写在函数里面，不能写在函数外面，如下这种初始化是会报错的：
#include<stdio.h>
struct student
{
char *name;
int age;
float height;
} stu;
stu.name="abc";
stu.age=15;
stu.height=1.72;
int main()
{
printf("姓名: %s\n",stu.name);
printf("age = %d\n",stu.age);
printf(" %.2f\n",stu.height);
return 0;
}
*/
补充：一种结构体初始化方法，可选择性初始化。
#include<stdio.h>
struct student
{
];
int height;
};
int main()
{
struct student a =
{
.name[]='m',
.name="machael",
.height=,
};
printf(]);
printf("%s\n", a.name);
printf("%d\n", a.height);
;
}
1.2 结构体不允许对本身的递归定义，即结构体内部不能包含结构体本身，但是可以包含别的结构体。
struct date
{
int year;
int month;
int day;
};
struct student
{
int age;
struct date birthday;
};
void test()
{
,{,,}}; // {2015,1,1}这个括号可加可不加，加了思路更清晰
printf("%d\n",stu.age);
printf("%d\n",stu.birthday.year);
printf("%d\n",stu.birthday.month);
printf("%d\n",stu.birthday.day);
}
1.3 结构体与函数--作为函数参数
//修改结构体成员变量的值--比较test1和test2的差别 //先参考基本数据类型修改其变量值-比较test3和test4的差别
void change3(int p3)
{
p3=10;
}
void test3(void)
{
int person3;
person3=30;
printf("%d\n",person3); //30
change3(person3);
printf("%d\n",person3); //30
}
void change4(int* p4)
{
*p4=10;
}
void test4(void)
{
int person4;
person4=30;
printf("%d\n",person4); //30
change4(&person4);
printf("%d\n",person4); //10
}
//再看结构体修改其变量值struct Person
{
int age1;
int age2;
};
void change1(struct Person p1)
{
p1.age1=;
}
void test1(void)
{
};
printf("%d\n",person1.age1); //27
change1(person1);
printf("%d\n",person1.age1); //27
}
void change2(struct Person* p2)
{
(*p2).age2=;
}
void test2(void)
{
struct Person person2;
person2.age2=;
printf("%d\n",person2.age2); //27
change2(&person2);
printf("%d\n",person2.age2); //9
}
1.4 结构体与数组
struct student
{
int age;
char *name;
float height;
}a[]={{,,"lmj",1.90}};
void test(void)
{
printf(].age);
printf(].name);
printf(].height);
printf(].age);
printf(].name);
printf(].height);
}
1.5 结构体与指针
struct Person
{
int age;
];
};
void test()
{
,};
struct Person *p;
p=&person;
printf("%d\n",person.age);
printf("%d\n",(*p).age);
printf("%d\n",p->age);
printf(]);
}
（2）思考：空结构体占多大内存？这是C语言的灰色地带，不同的编译器下面不同，在gcc编译器下面，占用0个字节，a和b的地址相同。在g++下面运行，占用1个字节，a和b的地址相差1。
struct test
{
};
void Test(void)
{
struct test a;
struct test b;
printf("%d\n",sizeof(struct test));
printf("%d, %x\n",sizeof(a), &a);
printf("%d, %x\n",sizeof(b), &b);
}
（3）由结构体产生柔性数组。这是结构体的一个特点。
柔性数组的概念：数组大小待定的数组。因为C语言中结构体的最后一个元素可以是大未知的数组，所以可以根据这个特性由结构体产生柔性数组。
//柔性数组的大小是4，也就是 int array[];占用0个字节typedef struct
{
int length;
int a[];
}FlexibleArray;
void test(void)
{
int i;
FlexibleArray* space=(FlexibleArray*)malloc(); //siezeof(int)*8 决定柔性数组的大小
(*space).length=;
;i<(*space).length;i++)
{
(*space).a[i]=i+;
printf("%d\n",(*space).a[i]);
}
free(space);
}
19、union
（1）用法和结构体类似，初始化的时候也可以分完全初始化和部分初始化。但是完全初始化的时候只能写一个初始化值，它结构体不同，它虽然定义了几个变量，实际上每次只有一个变量起作用，
所以完全初始化的时候只能共用一个，实际应用不用完全初始化。
//会报错--[Error] too many initializers for 'name' ，只能初始化一个
union name
{
char c;
int a;
int b;
}d={,};
//正确方式
union name
{
char c;
int a;
int b;
}d={'H'};
（2）union和struct比较
相同点：都可以定义多个成员，且定义方式类似。
不同点：结构体大小由所有成员决定，等于所有成员所占大小之和，而union的大小由最大的成员的大小决定。 结构体所有成员都有自己的内存空间，而union所有成员共享同一块大小的内存，一次只能使用其中的一个成员。
（3）对某一个成员赋值，会覆盖其他成员的值。
（4）union的使用受操作系统的大小端的影响。小端模式：低位存低字节，高位存高字节。大端模式：低位存高字节，高位存低字节。下面程序中，如果操作系统是小端模式，打印结果为1，如果操作系统是大端模式，打印结果为0。
#include <stdio.h>
union Test
{·
int i;
char j;
};
int test(void);
int main()
{
;
m=test();
printf("%d\n",m);
;
}
int test(void)
{
union Test a;
a.i = ;
return a.j;
}
反过来，可以用union验证操作系统的大小端。上面程序中，如果打印结果为1，那么操作系统是小端模式。如果打印结果为0，操作系统是大端模式。
20、枚举
（1）枚举与宏定义有关系，它是宏定义的一种优化，现实中两种都有人用。但是用枚举的话有两个好处：第一，阅读代码时更清晰，用枚举列举定义，一看这几个就是一伙的。第二，人非圣贤，万一程序中将变量赋值了一个N，用宏定义定义的话，会执行：default:break; 而用枚举的话，直接报错，我们能迅速找到错误。举个例子：
#include <stdio.h>
#if 0
#define SUN 0
#define MON 1
#define TUE 2
#define WEN 3
#define THR 4
#define FRI 5
#define SAT 6
#define N 10
#endif
#if 1
enum week
{
SUN,MON,TUE,WEN,THR,FRI,SAT,
};
#endif
int main(void)
{
enum week today; // 使用enum week类型，来定义一个枚举变量today
today = SAT;
switch (today)
{
case MON:printf("hao kun a.\n");break;
case TUE:printf("2\n");break;
case WEN:printf("3.\n");break;
case THR:printf("4\n");break;
case FRI:printf("5.\n");break;
case SAT:printf("6\n");break;
case SUN:printf("ha ha.\n");break;
default:break;
}
;
}
（2）枚举定义类似于结构体和共用体，但初始化方式不同。默认第一个枚举常量为0，其他枚举常量在前一个值的基础上一次加1。
（3）枚举类型和#define的区别：①宏常量只是简单的进行值替换，无类型信息，不是真正意义上的常量，枚举常量是一种特定类型的常量。②#define宏常量无法被调试，枚举常量可以。
21、typedef
（1）作用：给各种数据类型起一个别名。
（2）用法归纳
2.1 给基本数据类型起别名
void test(void)
{
typedef int Integer;
typedef Integer MyInteger;
typedef unsigned int UInteger;
;
Integer b = ;
UInteger c = ;
MyInteger d = ;
printf("%d\n",a);
printf("%d\n",b);
printf("%d\n",c);
printf("%d\n",d);
}
2.2 给指针类型起别名
void test1(void)
{
char* s = "pual";
printf("%s\n",s);
typedef char* String;
String s1 = "wade";
printf("%s\n",s1);
}
2.3 给结构体起别名
void test2(void)
{
typedef struct
{
float x;
float y;
}Point;
Point p = {,};
printf("%f\n",p.x);
printf("%f\n",p.y);
}
2.4 给结构体指针起别名
//先给结构体起一个别名,再给指向结构体的指针起一个别名
void test3_1(void)
{
typedef struct
{
float x;
float y;
}Point;
typedef Point* PP;
Point point = {10.0f, 20.0f};
PP pp = &point;
printf("x=%f, y=%f\n", pp->x, pp->y);
printf("x=%f, y=%f\n", (*pp).x,(*pp).y);
printf("x=%f, y=%f\n", point.x, point.y);
}
//直接给指向结构体的指针起一个别名
void test3_2(void)
{
typedef struct Point {
float x;
float y;
}* PP;
struct Point point={1.0f, 2.0f};
PP pp = &point;
printf("x=%f, y=%f\n", pp->x, pp->y);
printf("x=%f, y=%f\n", (*pp).x,(*pp).y);
printf("x=%f, y=%f\n", point.x, point.y);
}
2.5 给枚举起别名（类似于结构体）
void test4(void)
{
typedef enum
{
spring,
summer,
autumn=,
winter, //最后一个逗号可加可不加
}Season;
Season s1 = spring;
Season s2 = autumn;
Season s3 = winter;
printf("%d\n",s1);
printf("%d\n",s2);
printf("%d\n",s3);
printf("%d\n",winter);
}
2.6 给指向函数的指针定义一个别名
int sum(int a, int b)
{
int c = a + b;
printf("%d+%d=%d\n", a, b, c);
return c;
}
//不用typedef起别名时的指向函数的指针
void test5_1(void)
{
int (*p)(int, int);
;
p = sum;
receive_sum=(*p)(, );
printf("%d\n",receive_sum);
}
//给指向函数的指针定义一个别名（这个跟之前的不一样，在这里SumPoint就是别名--int (* )(int,int) ）
void test5_2(void)
{
typedef int (*SumPoint)(int,int);
;
SumPoint p = sum;
receive_sum=(*p)(, );
printf("%d\n",receive_sum);
}
2.7 给数组类型起一个别名
//数组类型由元素类型和数组大小共同决定
//标准：typedef type(name)[size];
//举例：typedef int(INT5)[5];
void test6(void)
{
typedef ];
AINT5 a={,,,,}; //这样就定义就等价与int a[5];
printf(]);
printf(]);
}
（3）给一种数据类型起一个别名最好用typedef，而不用宏定义。理由如下：
typedef char* String1; //typedef是数据类型替换
#define String2 char* //宏定义纯粹是字符串替换
String1 s1,s2;
//相当于
char* s1;
char* s2;
String2 s3,s4;
//相当于
char* s3;
char s4;
22、goto
这个关键字尽量不要用。据说高手编程不用goto，因为C语言是一门面向过程的结构化语言，它程序的结构有3种，顺序执行，选择执行，循环执行。再复杂的C程序也是由这三种结构组合而成的。goto带有浓厚的汇编特性，类似于汇编里面的跳转指令，使得C程序以第四种方式运行，破坏了程序的结构化特性。