预处理、宏定义、指针

预处理命令

预处理:gcc -E main.c -o main.i -----------文本替换，全部换成c语言

        作用： 预处理是编译过程中的第一步，它处理源代码中的预处理指令。预处理指令                         以 # 开 头，如 #include、#define、#ifdef 等。

         可以用vim打开main.i文件，在文件最后（G到达文件底部gg到达文件开头）查看预处理后的           程序。

编译:gcc -S main.c -o main.s------检查语法

        作用： 编译是将经过预处理的源代码转换成汇编语言代码的过程

汇编:gcc -c main.s -o main.o------将汇编语言

        作用： 汇编是将汇编语言代码转换成机器语言代码（即目标代码）的过程

链接:gcc main.o -o main

        作用： 链接是将一个或多个目标文件及其所需的库文件组合成一个可执行文件或共享库的过          程。

执行：./main

注意：

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

预处理: //作 文本的 替换 
1.宏定义 
2.文件包含 
3.条件编译 

宏定义

语法:
  //  #define 标识符 字符串              
    #define 宏名   宏值  
   
   注意:
    1. 预处理命令 都是以 # 开头的 
    2. 宏名 命名规则 和 之前标识符命名规则一致 
       注:
          宏名一般都写大写 ，以区别与普通变量名 
    3. 预处理 实际上 是将 宏名 用 宏值(预处理阶段的 字符串) 原样替换 
       //文本替换 
       注意:
           c语言字符串中出现的 "宏名" 不会被替换 
           
    4. 应用 
       a. 提高代码可读性   
       b. 一改全改，方便代码修改 
     
    5. 宏名的 作用域

        从定义的位置开始往下作用，但对于本身上面的宏定义需要用到本身，也不影响，一并属于预处理。
    
    #undef 宏名   
    表示 取消 宏名的 定义 
    
    注意:
       只是在预处理阶段发挥作用。
       
       作用范围:
       从定义处开始，到 #undef 结束
eg:

  #define N 10

 int n; //变量名 
  含义:
      表示将来 代码中出现的N 都代表10 
      
      则:
         编写代码时，可以使用N表示数字10 

带参宏定义

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

带参宏定义，用法类似于函数，但无需数据类型

考点：原样替换，c语言优先级会影响结果。（重点）

  1 #include <stdio.h>
  2 #define add(a,b) a+b
  3 #define cheng(a,b) a*b
  4 #define chu(a,b) a/b
  5 #define jian(a,b) a-b
  6 
  7 
  8 int main()
  9 {
 10     int x = 20;
 11     int y = 4;
 12     printf("a + b = %d\n",add(x,y));
 13     printf("a * b = %d\n",cheng(x,y));//如果传入cheng（1+2,3+4）//得到1+2*3+4=11   考点
 14     printf("a / b = %d\n",chu(x,y));
 15     printf("a - b = %d\n",jian(x,y));                                                                                                                         
 16     return 0;
 17 }
~      

文件包含

        #include <文件名>

        #include "文件名"

<>与“”区别  ：在于查找头文件的方式不一样。

        <>   ；到系统，默认的路径下寻找对应的头文件。

        “”   ：表示先到当下目录下寻找头文件，如果没有吧，再到系统默认路径下寻找。

 条件编译

 (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
   ...
  #endif

包头文件，防止多次包含，带来重复定义的问题 ，并且多个c文件需要同时编译， 只允许有一个main函数。

main.c文件中是函数的主体，如果是函数，可以没有main函数，其main.h文件中main.c中的函数需要声明，加上#ifndefine。

指针

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型数据的指针类型 
                     
  

3. 指针变量的引用
   int a = 10;
   int *p = &a; //p指向a  ---因为p中保存了a的地址
   
   
   * //指针运算符   
     //单目运算 
     //运算对象 --- 只能指针(地址)
   
   *p //表示访问 p所指向的 基类型的 内存空间 
   
   *p //间接访问 
      //通过a访问的 -- 直接访问 
      
      step1: 首先拿出p中地址，到内存中定位 
      step2: 偏移出sizeof(基类型)大小的一块空间 
      step3: 将偏移出的这块空间，当做一个基类型变量来看   //*p运算完的效果  
      
     *p //运算效果 相当于就是一个基类型的变量 
                
   *p <=> a 
   
   int a; // 
        a 的数据类型 int 
       &a 的数据类型 int* //地址这种数据---对应到一种数据类型 --指针类型 
                          //
   float b;
         &b //float*