预处理详细介绍

 __FILE__ //进⾏编译的源⽂件
 __LINE__ //⽂件当前的⾏号
 __DATE__ //⽂件被编译的⽇期
 __TIME__ //⽂件被编译的时间
 __STDC__ //如果编译器遵循ANSIC，其值为1，否则未定义

printf("file:%s line:%d\n",__FILE__,__LINE__);//举例

#define name stuff//name是常量名字,stuff是常量内容

 #define MAX 1000
 #define reg register//为register这个关键字，创建⼀个简短的名字
 #define do_forever for(;;)//⽤更形象的符号来替换⼀种实现
 #define CASE break;case //在写case语句的时候⾃动把break写上。
 // 如果定义的stuff过⻓,可以分成⼏⾏写,除了最后⼀⾏外,每⾏的后⾯都加⼀个反斜杠(续⾏符).
 #define DEBUG_PRINT printf("file:%s\tline:%d\t \
 date:%s\ttime:%s\n" ,\
 __FILE__,__LINE__ , \
 __DATE__,__TIME__ )

 #define MAX 1000;
 #define MAX 1000

if(condition)
 max = MAX;
 else
 max = 0;

//宏的申明方式
#define name( parament-list ) stuff
//其中的parament-list是⼀个由逗号隔开的符号表,它们可能出现在stuff中的参数列表

#define SQUARE( x ) x * x//这是求一个数的平方的宏定义

 int a = 5;
 printf("%d\n" ,SQUARE( a + 1) );

printf ("%d\n",a + 1 * a + 1 );

#define SQUARE(x) (x) * (x)

printf ("%d\n",(a + 1) * (a + 1) );

 int a = 5;
 printf("%d\n" ,10 * DOUBLE(a));

printf ("%d\n",10 * (5) + (5));

#define DOUBLE(x) ( ( x ) + ( x ) )

//实例
#include <stdio.h>
#define SQUARE(x) (x)*(x)
int main()
{
  int a=10;
  int b=SQUARE(a);
  printf("%d\n",b);
  return 0;
}//结果输出:100

 x+1;//不带副作⽤
 x++;//带有副作⽤

#define MAX(a, b) ( (a) > (b) ? (a) : (b) )
 x = 5;
 y = 8;
 z = MAX(x++, y++);
 printf("x=%d y=%d z=%d\n", x, y, z);//输出的结果是什么？

z = ( (x++) > (y++) ? (x++) : (y++));
//所以输出的结果是：x=6 y=10 z=9

#define MAX(a, b) ((a)>(b)?(a):(b))

 #define MALLOC(num, type)\
 (type )malloc(num sizeof(type))
 MALLOC(10, int);//类型作为参数
 //预处理器替换之后：
 (int *)malloc(10 sizeof(int));

//宏的形式求两个数的较大值
#include <stdio.h>
#define MAX(x,y) ((x)>(y)?(x):(y))
int main()
{
  int a=10;
  int b=12;
  int m1=MAX(a++,b++);
  printf("m1=%d\n",m1);
}//结果输出:m1=13

//函数的形式求两个数的较大值
#include <stdio.h>
int Max(int x,int y)
{
  return x>y?x:y;
}
int main()
{
  int a=10;
  int b=12;
  int m2=Max(a++,b++);
  printf("m2=%d\n",m2);
  return 0;
}//结果输出:m2=12

#define PRINT(n) printf("the value of "#n " is %d", n);

printf("the value of ""a" " is %d", a);

the value of a is 10

#include <stdio.h>
int main()
{
  int a=10;
  printf("the value of a is %d\n",a);
  float b=3.14f;
  printf("the value of b is %f\n",b);
  return 0;
}

int int_max(int x, int y)
 {
 return x > y ? x : y;
 }
 float float_max(float x, float y)
 {
 return x > y ? x : y;
 }

 #include <stdio.h>
 #define GENERIC_MAX(type)     \     //产生函数的模具
 type type##_max(type x, type y)\
 {                 \
 return (x>y?x:y); \
 }
 GENERIC_MAX(int) //替换到宏体内后int##_max ⽣成了新的符号 int_max做函数名
 GENERIC_MAX(float) //替换到宏体内后float##_max ⽣成了新的符号 float_max做函数名
 int main()
 {
 int m = int_max(2, 3);
 printf("%d\n", m);
 float fm = float_max(3.5f, 4.5f);
 printf("%f\n", fm);
 return 0;
 }//在实际开发过程中##使⽤的很少，很难取出⾮常贴切的例⼦。

#undef NAME
//如果现存的⼀个名字需要被重新定义，那么它的旧名字⾸先要被移除。

#include <stdio.h>
 int main()
 {
 int array [ARRAY_SIZE];
 int i = 0;
 for(i = 0; i< ARRAY_SIZE; i ++)
 {
 array[i] = i;
 }
 for(i = 0; i< ARRAY_SIZE; i ++)
 {
 printf("%d " ,array[i]);
 }
 printf("\n" );
 return 0;
 }
 //编译指令
 //linux 环境演⽰
 gcc -D ARRAY_SIZE=10 programe.c

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#define SZ 10
int main()
{
	int arr[SZ] ;
	int i = 0;
	for (i = 0; i < SZ; i++)
	{
		arr[i] = i + 1;
	}
	for (i = 0; i < SZ; i++)
	{
		printf("%d", arr[i]);
	}
	printf("\n");
	return 0;
}

 #include <stdio.h>
 #define __DEBUG__
 int main()
 {
 int i = 0;
 int arr[10] = {0};
 for(i=0; i<10; i++)
 {
 arr[i] = i;
 #ifdef __DEBUG__
 printf("%d\n", arr[i]);//为了观察数组是否赋值成功。
 #endif //__DEBUG__
 }
 return 0;
 }

 //常⻅的条件编译指令
 1.单个分支的条件编译
 #if 常量表达式
 //...
 #endif
//常量表达式由预处理器求值。
 如：
 #define __DEBUG__ 1
 #if __DEBUG__
 //..
 #endif

#define M 100
int main()
{
 #if M>200
     printf("hehe\n");
 #endif
     printf("haha\n");
     return 0;
}

2.多个分⽀的条件编译
 #if 常量表达式
 //...
 #elif 常量表达式
 //...
 #else
 //...
 #endif

#define M 100
int main()
{
 #if M<50
     printf("hehe\n");
 #elif M>=50&&M<=80
     printf("haha\n");
 #else 
     printf("heihei\n");
#endif
return 0;
}

3.判断是否被定义
 #if defined(symbol)
 #ifdef symbol
 #if !defined(symbol)
 #ifndef symbol

4.嵌套指令
 #if defined(OS_UNIX)
 #ifdef OPTION1
 unix_version_option1();
 #endif
 #ifdef OPTION2
 unix_version_option2();
 #endif
 #elif defined(OS_MSDOS)
 #ifdef OPTION2
 msdos_version_option2();
 #endif
 #endif

#include "filename"

/usr/include

C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include

#include <filename.h>

//test.c
#include "test.h"
#include "test.h"
#include "test.h"
#include "test.h"
#include "test.h"
int main()
{
return 0;
}

//test.h
void test();
struct Stu
{
int id;
char name[20];
};

#ifndef __TEST_H__
#define __TEST_H__
//头⽂件的内容
#endif //__TEST_H__
//或者
#pragma once
//就可以避免头⽂件的重复引⼊

 #error
 #pragma
 #line
 ...
 不做介绍，⾃⼰去了解。
 #pragma pack()在之前结构体部分介绍了.