重温C语言10---预处理与宏定义

1.预处理基本介绍：

-1.在使用空函数之前，应该用#include引入对应的头文件。这种以**#号开头的命令称为预处理命令**

-2.这些在编译之前对源文件进行简单加工的过程，称为预处理(即预先处理、提前处理)

-3.预处理主要是处理以#开头的命令，例如**#include **等。预处理命令要放在所有函数之外，而且一般都放在源文件的前面

-4.预处理是C语言的一个重要功能，由预处理程序完成。当对源文件进行编译时，系统将自动调用预处理程序对源程序中的预处理部分作处理。处理完毕自动进入对源程序的编译

-5.C语言提供了多种预处理功能，如宏定义、文件包含、条件编译等，合理地使用它们会使编写地程序便于阅读、修改、移植和调试，也有利于模块化程序设计。

2.快速入门

-1要求：

开发一个C程序，让他暂停5秒以后再输出内容"hello world",并且要求跨平台，在windows.linux系统下都可以运行，如何处理：

-2提示：

1. windows平台下的暂停函数地原型是：void Sleep(DWORD dwMilliseconds),参数的单位是：“毫秒”，位于文件。
2. Linux平台下暂停函数的原型usigned int sleep(usigned int seconds).参数的单位为：“秒”位于头文件
3. #if、#elif、#endif就是预处理命令，他们都是编译之前由预处理程序来执行的。

#include
//说明：在windows操作系统和linux操作系统下生成的源码是不一样的
/*
这是在windows的源码
#include
int main(){
Sleep(200);
puts("hello world");
}
*/

#if _WIN32  //如果是windows平台，就执行下面那句话
#include 

#elif _linux_//否则判断是不是linux，如果是linux就引入
#include
#endif
int main(){
    //不同平台下调用不同的函数
#if _WIN32//识别windows平台
    Sleep(200);//使用毫秒来计算
   //printf("这是windows平台");
#elif _linux_//识别linux平台
    Sleep(5);
#endif
    puts("helllo world");//这个也是输出语句输出一句话！
    return 0;
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

3.C语言宏定义

1）基本介绍

-1.#define叫做宏定义命令，他也是C语言预处理命令的一种。所谓宏定义，就是用一个标识符来表示一个字符串，如果在后面的代码出现了该标识符，那么就全部替换成指定的字符串

#define N 100
int main(){
int sum=20+N;//20+100=120
printf("%d\n",sum);
return 0;
}
1
2
3
4
5
6

-2小结

• int sum=20+N,N被100代替了
• #define N100就是宏定义，N为宏名，100是宏的内容（宏所表示的字符串），在预处理阶段，对程序中所有出现的“宏名”，预处理都会用宏定义总的字符串去代换，这想称为“宏替换”或者"宏展开"
• 宏定义是由源程序中的宏定义命令#define完成的，宏替换是由预处理程序完成的

-3.宏定义的形式

#define 宏名 字符串；

• #表示这是一条预处理命令，所有的预处理命令都以#开头。宏名是标识符的一种，命名规则和变量相同。字符串可以是数字、表达式、if语句、函数等
• 这里所说的字符串是一般意义上的字符序列，不要和C语言中的字符串等同。他不需要双引号
• 程序中反复使用的表达式就可以使用宏定义

-4.宏定义注意事项和细节

• 宏定义是用宏名来表示一个字符串，在宏展开时又以该字符串取代宏名，这只是一种简单的替换。字符串中可以含任何字符，他可以是常数、表达式、if语句、函数等，预处理程序对他不做任何检查，如有错误，只能在编译已被宏展开后的源程序发现的。

• 宏定义不是说明或语，在行尾不必加分号，如加上分号则连分号也一起替换

• 宏定义必须写在函数外，其作用域为宏定义命令起到源程序结束。如要终止其作用域可使用#undef命令

  #include 
  #define PI 3.1415926
  
  void main(){
      printf("PI=%f",PI);
      fu();
  }
  #undef PI//取消宏定义
  void fu(){
      printf("PI=%f",PI);
  }
  
  
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13

• 代码中的宏名如果被引号包围，那么预处理程序不对其作宏代替

  #include 
  #define OK 100
  int main(){
  printf("OK\n");
  return 0;
  }
  1
  2
  3
  4
  5
  6

• 宏定义允许嵌套，在宏定义的字符串可以使用已经定义的宏名，在宏展开时由预处理程序层层代换

  #include 
  #define PI 3.1415926
  #define y 1
  #define S PI*y*y
  void main(){
      printf("%f\n",S);//3.141593
      printf("%f",3.1415926*y*y);//3.141593
  }
  
  
  printf("%f",3.1415926*y*y);
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11

• 习惯上宏名用大写字母表示，以便于与变量区别。但也允许使用小写字符（最好还是规范一点）

• 可用宏定义标识数据类型，使书写更方便

  #include 
  #define UINT unsigned int;
  void main(){
      UINT a,b;//宏替换 unsigned int a, b;
  }
  1
  2
  3
  4
  5

• 宏定义表示数据类型和用typeof定义数据说明符的区别：宏定义只是简单的字符串替换，由预处理来处理：而typeof是在编译阶段由编译器处理的，它并不是简单的字符产串替换。而给原有的数据起一个新名字，将他作为一种新的数据类型

2）带参数的宏定义

-1.C语言允许使用宏带有参数。在宏定义中的参数称为：“形式参数”在宏调用中的参数称为“实际参数”，这点与函数十分相似

-2对带参数的宏，再展开过程中不仅要进行字符串替换，还要用实参去替换形参

-3.带参宏定义一般形式为#define宏名（形参列表）字符串，字符串中可以含有各个形参

-4.带参宏调用的一般形式为:宏名 [实参列表]；

3）带参宏定义的注意事项和细节

• 带参宏定义中，形参之间可以出现空格，但是宏名和形参列表之间不能有空格出现

  #include 
  /*
   * 说明：
   * 1.MAX就是带参数的宏
   * 2.(a,b)就是形参
   * 3.(a,b)?a:b时代参数的宏对应字符串该字符串中可以使用参数（形参）
   */
  #define MAX(a,b) ((a)>(b))? a:b //宏定义带参，两数之间比较大小。
  void main(){
    int x,y,max;
    printf("input two numbers:\n");
    fflush(stdout);
    scanf("%d%d",&x,&y);
    //调用带参数的宏
    /*
     * 1.MAX(x,y);调用带参数的宏
     * 2.在宏替换时，（预处理，由预处理器），会进行替换字符串的替换，同时会使用实参，去替换形参
     * 3.MAX(x,y)宏替换为：(x>y)?x:y
     */
    max =MAX(x,y);
    printf("两个数之间的最大数为max=%d\n",max);
  
  }
  
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24

• 在带参宏定义中，不会为形式参数分配内存，因此不必指明数据类型。而在宏调用中，实参包含了具体的数据，要用他们去替换形参，因此实参要指明数据类型

  #define MAX(a,b) (a>b)? a:b//没有明确的数据类型声明
  1

• 在宏定义中，字符串内的形参通常要用括号括起来避免出错

  #include 
  //#define SQ(y)y*y//带参的宏定义
  #define SQ(y)(y)*(y)//带参的宏定义
  void main(){
      int a,sq;
      printf("input a number: \n");
      fflush(stdout);
      scanf("%d",&a);
     // sq=SQ(a+1);//宏替换 a+1 * a+1(没加括号之前)
     sq=SQ(a+1);//(a+1)*(a+1 )
      printf("sq=%d\n",sq);
     // system("pause");
  }
  
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14

  3）带参宏定义和函数的区别

  -1，宏展开仅仅时字符串的替换，不会对表达式进行计算；宏在编译之前就被处理掉了，他没有机会去参与编译，也不会占用内存。

  -2.函数是一段可以重复使用的代码，会被编译，会给他分配内存，每次带哦用函数，就是执行这块内存中的代码

  -3.案例说明：要求使用函数平方值，使用宏计算平方值，并总结二者的区别

  #include 
  int SQL(int y){
      return (y)*(y);
  }
  int main(){
      int i=1;
      while(i<=5){
          printf("%d^2=%d\n",(i-1),SQL(i++));
      }
      return 0;
  }
  
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12

  采用宏定义：

  #include 
  #include 
  #define SQ(y)((y)*(y))
  int main(){
     int i=1;
      while(i<=5){//进入循环三次。得到的是1*1=1 3*3=9 5*5=25
          //分析
          //SQL(i++)宏调用 展开 (i++)(i++)
          printf("%d^2=%d\n",i,SQ(i++));
      }
      system("pause");
      return 0;
  
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14

  #include 
  #include 
  #define SQ(y)((y)*(y))
  int main(){
    printf("%d\n",SQ(5));//输出25
      system("pause");
      return 0;
  
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9

  3）C语言预处理命令总结

  预处理指令是以#号开头的代码行 #号必须是该行除了任何空白字符外的第一个字符。#后是指令关键字，在关键字和#号之间允许存在任意个数的空白字符和#号之间允许存在任意个数的空白字符，整行语句构成了一条预处理指令，该指令将在编译器进行编译之前对源代码做某些转换

  请参照如下表

  指令	说明
  #	空指令，无任何效果
  #include	包含一个源代码文件
  #define	定义宏
  #undef	取消已定义的宏
  #if	如果给定条件为真，则编译下面代码
  #ifdef	如果宏已经定义，则编译下列代码
  #ifndef	如果宏没有定义，则编译下面代码
  #elif	如果前面的#if给定条件不为真，当前条件为真，则编译下面代码
  #endif	结束一个#if…#else条件编译块

4.预处理指令使用注意事项

1）预处理功能是C语言特有功能，它是在对源程序正式编译前由预处理程序完成的

2）宏定义可以带有参数，宏调用时用实参代换形参，而不是**“值传送**”。

3）为了避免宏代换时发生错误，宏定义中的字符串应加上括号，字符串中出现的形式参数两边也应加上括号。

4）文件包含是预处理的一个重要功能，它可以用来把多个源文件连接成一个源文件进行编译，结果将生成一个目标文件

5）条件编译允许只编译源程序中满足条件的程序段，使生成的目标程序较短，从而减少了内存的开销并提高了程序的效率。

6）使用预处理功能便于程序的修改、阅读、移植和调试。也便于实现模块化程序设计