09day（static、extern、typedef、const关键字使用、宏定义）

关键字

• Static静态变量

使用static关键字修饰的变量就是静态变量,修饰变量：static int var = 10;

静态变量没有初始化赋值，默认值为0
static 修饰全局变量的时候，这个全局变量只能在本文件中访问，不能在其它文件中访问，即便是 extern 外部声明也不可以。
不管函数调用多少次，静态局部变量只会定义一次，它的值会保存，
函数退出它的内存不会被释放，这个作用类似于全局变量
不管函数调用多少次，静态局部变量初始化赋值，只会赋值一次
static 修饰一个函数，则这个函数的只能在本文件中调用，不能被其他文件调用。static 修饰的变量存放在全局数据区的静态变量区（也就是数据段），包括全局静态变量和局部静态变量，都在全局数据区分配内存。初始化的时候自动初始化为 0

• 用法

修饰变量：可以被其它文件引用，当你在一个源文件中声明一个全局变量，并希望在另一个文件中使用这个全局变量时，你可以在使用的文件中使用 extern 关键字来声明该变量

• typedef:给复杂的声明、类型取别名

typedef + 数据类型 + 别名--》typedef unsigned int uint32_t; //用uint32_t代替unsigned int  

例子

typedef struct info
{
char name[10];
char sex;
int high;
}*stu, stu_info;
stu == struct info *
stu_info == struct info

• const:修饰局部变量

const int i = 10;  //const修饰的i空间为只读，不能通过变量修改空间的值,用const修饰变量时，一定要初始化，否则之后就不能再进行赋值了
情况一
const int i = 10;-->一定要初始化，否则之后就不能再进行赋值了
情况二
const int i ;
i = 10; -->错误情况--》因为只会在初始化时候初始化一次，后面i=10不能通过变量修改空间的值
局部变量写法二
int cont n = 5和const int n = 5写法是一样的，都是表示变量n的值不能被改变了，需要注意的是，用const修饰变量时，一定要给变脸初始化，否则之后就不能再进行赋值了。

const修饰常量静态字符串
const char* str="techdreamer";
如果没有const的修饰，我们可能会在后不经意间的修改代码，比如str[4]=’D’，这样会导致对只读内存区域的赋值，使程序异常终止
修饰全局变量
使用const进行修饰，防止不必要的人为修改
修饰常量指针
int i = 10;
const int *p = &i; //const修饰的p空间为只读，不能通过指针变量修改空间的值
（1）常量指针：指针本身就是常量，不能通过指针变量来改变空间的值
（2）指针常量 ：可以通过指针变量的解引用改变它所指向的变量空间值
比如：
int cnt=5;
const int* num=&cnt;
cnt=6; -->可以通过指针变量的解引用改变它所指向的变量空间值

• 指针常量

int i = 10;
int *const p = &i;
（1）指针常量：指针本身就是常量，不能通过指针变量来改变空间的值
（2）指针常量：可以通过指针变量的解引用改变它所指向的变量空间值
总结：
需要注意的是，指针常量指向的地址不能改变，但是地址中保存的数值是可以改变的，可以通过其他指向改地址的指针来修改

例子 int cnt=5; int tmp=&cnt; int const num=&cnt;
*tmp=6;

• 两者区别

区分常量指针和指针常量的关键就在于星号的位置，我们以星号为分界线。
如果const在星号的左边，则为常量指针
如果const在星号的右边则为指针常量
如果我们将星号读作‘指针’，将const读作‘常量’的话，内容正好符合。
const int * num；
int *const num；

宏定义及条件编译

认识程序编译环节
预处理--》编译--》汇编--》链接

预编译：这个过程主要的处理操作如下：
将所有的#define删除，并且展开所有的宏定义处理所有的条件预编译指令，如#if、#ifdef处理#include预编译指令，将被包含的文件插入到该预编译指令的位置。过滤所有的注释添加行号和文件名标识。
编译：这个过程主要的处理操作如下：
词法分析：将源代码的字符序列分割成一系列的记号。
语法分析：对记号进行语法分析，产生语法树。
语义分析：判断表达式是否有意义。
代码优化。
目标代码生成：生成汇编代码。
目标代码优化。
汇编：这个过程主要是将汇编代码转变成机器可以执行的指令。
链接：将不同的源文件产生的目标文件进行链接，从而形成一个可以执行的程序
链接分为静态链接和动态链接。
静态链接，是在链接的时候就已经把要调用的函数或者过程链接到了生成的可执行文件中，就算你在去
把静态库删除也不会影响可执行程序的执行；生成的静态链接库，Windows下以.lib为后缀，Linux下
以.a为后缀。
动态链接，是在链接的时候没有把调用的函数代码链接进去，而是在执行的过程中，再去找要链接的函
数，生成的可执行文件中没有函数代码，只包含函数的重定位信息，所以当你删除动态库时，可执行程
序就不能运行。生成的动态链接库，Windows下以.dll为后缀，Linux下以.so为后缀。

• #define
  

#define 定义标识符 -->在 #define 定义标识符时，尽量不要在末尾加分号！（必须加的情况除外）
#define  NUM          100           （NUM 代替 100）

- 写宏定义编写注意事项

a.宏定义编写尽量在大写
b.宏定义表示的内容尽量使用()括起来
c.宏定义实现函数相关功能尽量简短

• 预处理（规定的）

FILE ‘进行编译的源文件’
LINE ‘文件当前的行号’
DATE ‘文件被编译的日期’
TIME ‘文件被编译的时间’
FUNCTION ‘返回所在函数的函数名’

• 宏条件编译

ifdef (宏存在)    
#ifndef(宏不存在) 
#else 
#endif
例子
#include <stdio.h>
 
#define __DEBUG__ // 就像一个开关一样
 
int main(void)
{
    int arr[10] = {0};
    int i = 0;
    for (i = 0; i < 10; i++) {
        arr[i] = i;
        #ifdef __DEBUG__ // 因为__DEBUG__被定义了，所以为真
        printf("%d ", arr[i]); // 就打印数组    
        #endif // 包尾
    }
 
    return 0;
}

• 条件编译

#if(条件) 
#else 
#elif  
#endif
例子
#include <stdio.h>
 
int main(void) {
#if 1
    printf("Hello,World!\n");
#endif
 
    return 0;
}

• 三、文件包含

头文件被包含的方式
库文件的包含，C语言库中提供函数的头文件使用<>
#incluide <filename>
本地文件的包含，自定义的函数的头文件使用
"#inlcude "filename"
< > 和 " " 包含头文件的本质区别：查找的策略的区别
" " 的查找策略：先在源文件所在的目录下查找。如果该头文件未找到，则在库函数的头文件目录下查找。（如果仍然找不到，就提示编译错误）
< > 的查找策略：直接去标准路径下去查找。（如果仍然找不到，就提示编译错误）

嵌套文件的包含头文件重复引入的情况：

comm.h 和 comm.c 是公共模块。
test1.h 和 test1.c 使用了公共模块。
test2.h 和 test2.c 使用了公共模块。
test.h 和 test.c 使用了 test1 模块和 test2 模块。
这样最终程序中就会出现两份 comm.h 的内容，这样就造成了文件内容的重复。

• 那么如何避免头文件的重复引入呢？

使用条件编译指令，每个头文件的开头写：
#ifndef TEST_H
#define TEST_H
// 头文件的内容
#endif