预处理，指针(i)(12)

预处理:

    编程流程:
    1.编辑 
    2.编译   gcc main.c  //a.out 
    3.运行 
    4.调试 
    

编译过程:
  1.预处理  
    //预编译 -- 将 代码中相关 预处理命令执行 最终生产一个 只包含c语言代码的文件 
  2.编译 
    //编译   -- 对语法进行检查,将这个c的源代码 生产 汇编代码 
  3.汇编 
    //汇编   -- 表示将 汇编源代码 最终生成 机器代码 //object 
  4.链接
    //链接   -- 将使用到的其它代码了链接到一起 生成 最终可执行文件

1.宏定义 

宏定义（Macro Definition）是一种预处理指令，用于在编译之前将代码中的某个标识符替换为指定的文本。

基本形式：宏定义使用#define指令进行定义，语法为：

#define 宏名 替换文本

其中，宏名是标识符或符号，替换文本是希望宏名在编译时替换的实际文本内容。例如：

#define PI 3.14159

   注意:
1. 预处理命令 都是以 # 开头的 
2. 宏名 命名规则 和 之前标识符命名规则一致 
  注:
  宏名一般都写大写 ，以区别与普通变量名 
3. 预处理 实际上 是将 宏名 用 宏值(预处理阶段的 字符串) 原样替换 
  //文本替换 
  注意:
  c语言字符串中出现的 "宏名" 不会被替换 

4. 应用 
  a. 提高代码可读性   
  b. 一改全改，方便代码修改 

5. 宏名的 作用域    
  #undef 宏名   
  表示 取消 宏名的 定义 

注意:
  只是在预处理阶段发挥作用。
  作用范围:
  从定义处开始，到 #undef 结束

eg:  #define N 10

含义:表示将来 代码中出现的N 都代表10

        则:
         编写代码时，可以使用N表示数字10 

练习:
      求一个 圆的 周长和面积 

#include<stdio.h>

#define PI 3.1415

int main(void)
{
	float r;
	scanf("%f",&r);

	float s,c;
	s = PI*r*r;
	c = PI*r*2;

	printf("s = %f\n",s);
	printf("c = %f\n",c);

	return 0;
}

1.2带参宏定义: //宏函数 

语法:
    #define 宏名(参数) 宏值

eg:
   #define ADD(a,b) a+b

注意:
1.带参宏 和 函数有本质的    区别
     a.处理阶段不一样 
       宏定义 --预处理阶段 
       函数   --编译阶段 
     b.使用不一样
       宏     -- 预处理阶段  就使用结束了 
         宏的使用，本质上，是文本的原样替换
         参数 
             宏的参数，只是进行 文本替换用，不进行语法检查                  
       函数   -- 调用时，进行使用 
           函数的使用，本质上是函数代码的调用 
           参数 
            函数的参数，是有类型的，编译阶段是要进行类型检查的 
                     
    c.应用 
        一般对于一些短小代码 ，考虑写成带参宏
        不超过5行的代码         
           
    d.宏的副作用 
       处理:
           把能加括号的地方都加括号 
    e.注意
      宏定义 必须 写在一行 
      续行符

练习:
    输入两个数 
    实现4则运算
    分别用带参宏实现

#include<stdio.h>

#define JIA(a,b) a+b
#define JIAN(a,b) a-b
#define CHEN(a,b) a*b
#define CHU(a,b) a/b

int main(void)
{
	int x,y;
	scanf("%d%d",&x,&y);

	printf("x + y = %d\n",JIA(x,y));
	printf("x - y = %d\n",JIAN(x,y));
	printf("x * y = %d\n",CHEN(x,y));
	printf("x / y = %d\n",CHU(x,y));

	return 0;
}

此代码可以实现功能，但不严谨，应加上括号

#define MIN(x, y) ((x) < (y) ? (x) : (y))

eg:

这样写的话，在预处理阶段会处理成这样：

使用时应注意加括号；

另外，带参宏定义只允许写在一行，或者加续行符，\但是不能有空格

2.文件包含 

  #include <文件名>
  #include "文件名"

  <> 与 "" 
 区别:
    在于，查找头文件的方式不一样 
   <>  //到系统默认的路径寻找对应的头文件 
   ""  //表示先到当下目录下寻找头文件，如没有，再到系统默认路径下寻找 

3.条件编译 

  (1). 
  #ifdef 标识符
    程序段 1
  #else
    程序段 2
  #endif

含义:
     如果 定义了 标识符 
     则 预处理程序段1  //就是将程序段1的代码 保留 
     否则 
        保留程序段2

用途:
      //1.调试代码 
      //2.设计头文件

(2)
     #ifndef 标识符
        程序段1
     #else
        程序段2
     #endif

含义:
     如果 没有定义了 标识符 
     则 预处理 程序段1  //就是将程序段1的代码 保留 
     否则 
        处理 程序段2

防止多次包含，带来重复定义的问题 

(3) 
    #if 表达式
      程序段1
    #else
      程序段2
    #endif

含义:
       表达式为真 处理程序段1 表达式为假 处理程度段2     
eg:
  #if 0
   ...
  #endi

4.指针

指针一般分为三个阶段：

指针基础
  指针概念
  指针变量定义及引用
  指针传参 
指针进阶 
  指针+一维整型数组
  指针+一维字符型数组   
指针高级
  指针+二维整型数组 
  指针+二维字符数组 
  指针的数组
  指针+函数 
  指针+指针 

指针概念:
   地址 内存单元的编号 
---1. 指针 就是 地址

---2. 指针 也是一种数据类型 
      指针类型 
      这种数据类型 是专门用来处理 地址 这种数据

1 指针变量定义 

语法:
   基类型 * 指针变量名
   (1)基类型    
            //数据类型 
            整型
            浮点型 
            字符型 
            数据类型 
            指针类型 
            ....
            //结构体类型 ，函数类型 
           作用:            
               表示该指针类型 所指向的内存空间 存放什么类型的数据 
  (2).*   
          //定义时，表示此时定义的是一个 指针类型 的变量
  (3).指针变量名 
          //符合标识符命名规则 

  int * p; //pointer 

  
  int a = 10; //a所在的空间是用来存放 int(整型)类型的数据的
  float b = 10;
  int *p = &a;
  int *p = &b;(会报警告)
  
  &a //表示获得a所在空间的首地址 
     //表示 获得了一块 可以存在int型数据的内存空间的地址 

2 指针类型

  int *p;  //int *  ---整体叫指针类型 
  数据类型 变量名;
  
  int*    p; 
          //int* 含义 首先表示是一个 指针类型 
                     //表示指向int型数据的指针类型 

   int a; // 
        a 的数据类型 int 
       &a 的数据类型 int* //地址这种数据---对应到一种数据类型 --指针类型 

3. 指针变量的引用

   int a = 10;
   int *p = &a; //p指向a  ---因为p中保存了a的地址
   
   
   * //指针运算符   
     //单目运算 
     //运算对象 --- 只能指针(地址)
   
   *p //表示访问 p所指向的 基类型的 内存空间 
   
   *p //间接访问 
      //通过a访问的 -- 直接访问 
 

指针间接访问过程：    
  step1: 首先拿出p中地址，到内存中定位 
  step2: 偏移出sizeof(基类型)大小的一块空间 
  step3: 将偏移出的这块空间，当做一个基类型变量来看   //*p运算完的效果  
      
     *p //运算效果 相当于就是一个基类型的变量 
      *p <=> a