6-预处理知识点一：变量分类 1、普通局部变量普通局部变量同名就近原则 2、普通全局变量定义形式：定义在函数外边

知识点一：变量分类

1、普通局部变量

生命周期：离它最近的{}之间有效，离开{}的局部变量系统自动回收

存储区域：栈区

普通局部变量不初始化内容不确定

//定义形式：在 {} 里面定义的普通变量

void test01()
{
	int num = 10;	//普通局部变量
}

普通局部变量同名就近原则

void test01()
{
    //局部变量 同名 就近原则
    int data = 100;
    
    {
        int data = 200;
        printf("A:data = %d\n",data);//200
    }
    printf("B:data = %d\n",data);//100
}

2、普通全局变量

定义形式：定义在函数外边的变量就是普通全局变量

全局变量不初始化内容为0

//当前源文件(.c) 都有效
int data;	//普通全局变量 在函数外边定义
void test02()
{
}

3、静态局部变量

定义形式：在{}中定义，前面必须加static 修饰这样的变量

作用范围：离它最近的{}之间有效

生命周期：整个进程（程序结束的时候静态局部变量才被释放）

静态局部变量不初始化内容为0

只能被定义一次（重要）

void test01()
{
    static int num;	//静态局部变量
    return;
}

#include<stdio.h>
void fun1(void)
{
    int num = 10;//普通的局部变量
    num++;

    printf("num = %d\n",num);
    return;
}

void fun2(void)
{
    //静态局部变量 只能被初始化一次
    //静态局部变量 生命周期 是整个进程
    static int num = 10;	//静态局部变量
    num++;
    printf("num = %d\n",num);
    return;
}

int main(int argc,char *argv[])
{
	fun1();	//11
    fun1();	//11
    fun1();	//11
    fun1();	//11
	
    fun2();	//11
    fun2();	//12
    fun2();	//13
    fun2();	//14
    return 0;
}

4、静态全局变量

定义形式：在函数外边定义同时前面加static

作用范围：当前源文件有效不能在其他源文件中使用

生命周期：整个进程，（程序结束静态全局变量才被释放）

存储区域：全局区

静态全局变量不初始化内容为0

#include<stdio.h>
static int data = 10;	//静态全局变量
int main(int argc,char *argv[])
{
	return 0;
}

知识点二：变量分类

1、全局函数：普通函数

特点：其他源文件可以使用全局函数，必须加extern 声明

void my_fun(void)
{
    printf("(全局函数)普通函数\n");
    return;
}

2、静态函数（局部函数）

特点：只能在当前源文件使用不能在其他源文件使用

static void my_static_fun(void)
{
    printf("(静态函数)局部函数\n");
    return;
}

注意：如果想在其他源文件调用静态函数需要将静态函数封装在全局函数中。同时全局函数和静态函数必须是同一个源文件

fun.c

static void my_static_fun(void)
{
    printf("(静态函数)局部函数\n");
    return;
}

void my_fun(void)
{
    printf("(全局函数)普通函数\n");
    my_static_fun();
    return;
}

main.c

#include<stdio.h>
extern void my_fun(void);
//static void my_static_fun(void);

int main(int argc,char *argv[])
{
    my_fun();
    //my_static_fun();
    return 0;
}

知识点一：gcc编译过程

预处理：头文件包含、宏替换、条件编译、删除注释不做语法检查

编译：将预处理后的文件生成汇编文件语法检查

汇编：将汇编文件编译二进制文件

链接：将众多的二进制文件+库+启动代码生成可执行文件

gcc	-E	hel1o.c	-O	hel1o.i	1、预处理
gcc	-S	hello.i	-O	hello.s	2、编译
gcc	-C	hello.s	-O	hello.o	3、汇编
gcc		hello.o	-O	hello_elf	4、链接

知识点二：头文件包含

<> ：用于包含系统头文件

" " ：用于包含用户自定义头文件

#include <hehe.h>	//表示从系统的指定目录下寻找 hehe.h

#include "hehe.h"	//表示先从源文件所在的目录寻找,如果找不到再到系统指定的目录下找

知识点三：宏定义

宏只在当前源文件有效

宏名一般是大写，定义宏是后面不能加 ; 号

1、不带参数宏

形式：#define 宏名需要代替的内容

#define N "hehe"
void test01()
{
    //在预处理阶段 "hehe"替换 代码中所有出现的N ( 宏展开)
    printf("%s\n",N);	//hehe
    return;
}

终止宏的作用范围：

形式：#undef 宏名

#include<stdio.h>

//宏 后面不要加;
#define N "hehe"
int main(int argc,char *argv[])
{
    printf("%s\n",N);	//OK 识别的

    //使用#undef N终止 N的作用
    #undef N

    //printf("%s\n",N);	//err 不识别N
    return;
}

2、带参数的宏（宏函数）

形式：#define 宏名(参数1,参数2, ...) 需要代替的内容

//宏的参数a b 不能写类型
//#define MY_ ADD(int a, int b) a+b  //错误
#define MY_ADD(a,b) a+b

//调用宏名(参数)
MY_ ADD(10,20);     // 10+20

加小括号

#define MY_MUL1(a,b) a*b 
#define MY_MUL2(a,b) ((a)*(b))

int main(int argc,char *argv[])
{
    printf("MY_MUL1 = %d\n",MY_MUL1(10,20));    //200     //MY_ MULI (10,20)==10*20

    //MY MUL1 ( 10+10 , 20+20 )==10+10*20+20
    printf("MY_MUL1 = %d\n",MY_MUL1(10+10,20+20));    //230     //不能保证完整性 
    //MY_MUL2(10+10, 20+20) ==((10+10)*(20+20))
    printf("MY_MUL2 = %d\n",MY_MUL2(10+10,20+20));    //800     //保证完整性 
}

3、带参数的宏(宏函数)和普通函数的区别

带参数的宏(宏函数)：调用多少次就会展开多少次，执行代码的时候没有函数调用的过程，也不需要函数的出入栈，所以带参数的宏浪费空间节省了时间

代参的函数：代码只有一份，存在代码段，调用的时候去代码段读取函数指令，调用的时候要压栈(保存调用函数前的相关信息)，调用完出栈(恢复调用函数前的相关信息)，所以函数浪费了时间节省空间

知识点四：条件编译

如果xxx为真则运行语句1，为假运行语句2

//测试不存在
#ifndef XXX
	语句1;
#else
	语句2;
#endif

//测试存在
#ifdef XX
	语句1;
#else
	语句2;
#endif

//判断条件是否成立
#if 表达式
	语句1;
#else
	语句2;
#endif

//通过条件编译控制大小写的转换
#include<stdio.h>

int main(int argc,char *argv[])
{
    char buf[128] = "";
    printf("请输入字符串");
    // fgets 会获取换行符 
    fgets(buf,sizeof(buf),stdin);
    int i = 0;
    
    //去掉换行符  strlen返回的是字符串是长度 不包含'\0'
    //strlen(buf)-1 这是换行符的下标位置
    buf[strlen(buf)-1] = '\0';
    
    //buf[i]是取数组中的第i个元素的值
    //while(buf[i] != '\0')
    while(buf[i])   //最后一一个元素是'\0' == 0==假循环进不去
    {
#if 1
        if(buf[i]>= 'A' && buf[i]<='Z')
         buf[i] = buf[i]+32;
#else
         if(buf[i]<= 'a' && buf[i]<='z')
         buf[i] = buf[i]-32;
#endif
    i++;
    }
    printf("buf = %s\n",buf);
}

知识点五、防止头文件重复包含

方式一：#pragma once 编译器决定

#pragma once //放在头文件的最前方

//如果某个头文件有多份拷贝，本方法不能保证他们不被重复包含

方式二：c/c++的标准制定

#ifndef __头文件名_H__     //大写
#define __头文件名_H__
    //头文件具体内容
#endif

//缺点：不同头文件中的宏名不小心“撞车”，可能就会导致你看到头文件明明存在，但编译器却硬说找不到声明的状况

知识点六：原码、补码、反码

负数在计算机中存储的是补码

正数：原码 == 反码 == 补码

负数：反码 = 原码的符号位不变其他位取反，补码 = 反+1

	概念	概念	负数(-10)	备注
原码	数据的二进制形式	数据的二进制形式	1000 1010	以1字节为例
反码	就是原码	原码符号位不变，其他为取反	1111 0101
补码	就是原码	反码 + 1	1111 0110

计算机为啥要补码?

如果没有补码：

6-10 == -4

6+(-10) == -4

0000 0110

1000 1010

————————————————————————

1001 0000 == -16 (错误)

如果有补码：

0000 0110

1111 0110

--------------------------------------- 补码转原码：取反加一

1111 1100----->1000 0011--->1000 0100 ==> -4

补码的意义：减法运算变加法运算

以1字节分析：

有符号符: 1111 1111 ~ 1000 0000~0000 0000 ~ 0111 1111

-127 ~ -0 ~ +0 ~ +127

计算机为了扩数据的表示范围:故意将 -0 看成-128

-128~127

无符号数：0000 0000 ~ 1111 1111 == 0~255

总结：补码统一 0 的编码

+0 == 0000 0000 == 0000 0000 (反码) == 0000 0000 (补码)

-0 == 1000 0000 == 1111 1111 (反码) == 0000 0000 (补码)

6-预处理