1.预处理符号

#include <stdio.h>
 int main()
 {
 	printf("%s\n", __FILE__);//进⾏编译的源⽂件 
 	printf("%d\n", __LINE__);//⽂件当前的⾏号
 	printf("%s\n", __DATE__);//⽂件被编译的⽇期 
 	printf("%s\n", __TIME__);//⽂件被编译的时间 
 	printf("%d\n", __STDC__);//说明gcc完全遵循ANSI C

 	return 0;
 }

2.#define 定义常量

基本语法

#define name stuff

将华氏温度转化为对应的设置度，我们将系数进行了定义

3.#define 定义宏

#define机制包括了⼀个规定，允许把参数替换到⽂本中，这种实现通常称为宏（macro）或定义宏（define macro）。

#define name(parament-list) stuff

其中(parament-list)可以理解为参数
注意:参数列表的左括号必须与name紧邻，如果两者之间有任何空⽩存在，参数列表就会被解释为stuff的⼀部分。
举例:

#include<stdio.h>
#define SQUARE(n) n*n
#define DOUBLE(n) n+n
int main()
{
	printf("%d\n", SQUARE(5));//本意求得25
	printf("%d\n", SQUARE(5+1));//本意求得36
	printf("%d\n", DOUBLE(2)); //本意求得4
	printf("%d\n", 6*DOUBLE(2));//本意求得24
	return 0;
}

注意:宏只是对文本的替换也就是说
SQUARE(5)会替换成55
SQUARE(5+1)会替换成5+15+1
DOUBLE(2)会替换成2+2
6DOUBLE(2)会替换成62+2
这样的输出结果可能就不是我们的本意了
输出结果：

因此当我们使用宏定义时不应该吝啬圆括号也就是

#include<stdio.h>
#define SQUARE(n) ((n)*(n))//传的参数加括号，返回值再加括号
#define DOUBLE(n) ((n)+(n))
int main()
{
	printf("%d\n", SQUARE(5));//本意求得25
	printf("%d\n", SQUARE(5+1));//本意求得36
	printf("%d\n", DOUBLE(2)); //本意求得4
	printf("%d\n", 6*DOUBLE(2));//本意求得24
	return 0;
}

4.带有副作用的宏参数

有关副作用我在有关恼人的结合性一文已经解释过了（感兴趣的同学可以自己看看）。
当宏参数在宏的定义中出现超过⼀次的时候，如果参数带有副作⽤，那么你在使⽤这个宏的时候就可能出现危险，导致不可预测的后果。副作⽤就是表达式求值的时候出现的永久性效果。

#define MAX(x, y)  ((x)>(y)?(x):(y))

int main()
{
	int a = 10;
	int b = 20;
	//int m = MAX(a++, b++);
	int m = ((a++) > (b++) ? (a++) : (b++));
	       //10    > 20    ?  x    :  21  
	       // a=11 b=22
	printf("%d\n", m);//?
	printf("a=%d b=%d\n", a, b);

	return 0;
}

5.宏替换的规则

6.宏函数的对比

宏通常被应用于执行简单的运算
宏与函数的对比

但是宏能做到的函数一定做不到如

6.1 例子

6.1 .1

#define MALLOC(n, type)    (type*)malloc(n*sizeof(type))

int main()
{
	int *p = MALLOC(10, int);//也就是说宏的参数可以是一个类型
	if (p == NULL)
	{
		perror("error");
		return;
	}
	free(p);
	p = NULL;
	return 0;
}

函数能做到吗
还有两个例子，但是先介绍两个运算符#运算符和##运算符

6.1.2

#运算符将宏的⼀个参数转换为字符串字⾯量。它仅允许出现在带参数的宏的替换列表中。
#运算符所执⾏的操作可以理解为”字符串化“。

#define PRINT(format, n)    printf("the value of " #n " is " format"\n", n)
//这样的话打印下来的就是the value of n is n

int main()
{
	int a = 10;
	PRINT("%d", a);
	//printf("the value of " "a" " is " "%d""\n", a);
	//printf("the value of n is " "%d""\n", a);
	//printf("the value of a is %d\n", a);

	int b = 20;
	PRINT("%d", b);
	//printf("the value of b is %d\n", b);

	float f = 5.5f;
	PRINT("%f", f);
	//printf("the value of " "f" " is " "%f""\n", f)
	//printf("the value of n is " "%f""\n", f);
	//printf("the value of f is %f\n", f);


	return 0;
}

6.1.3

‘## 可以把位于它两边的符号合成⼀个符号，它允许宏定义从分离的⽂本⽚段创建标识符。 ## 被称为记号粘合
这样的连接必须产⽣⼀个合法的标识符。否则其结果就是未定义的。
为什么会要这样大家可以了解一下词法分析中的“分析法”

//函数也做不到
//生成函数的模板
#define GENERIC_MAX(type) \
type type##_max(type x, type y)\
{\
	return x>y?x:y;\
}

//使用上面的模板定义函数
//int_max
GENERIC_MAX(int)
//float_max
GENERIC_MAX(float)

int main()
{
	//
	printf("%d\n", int_max(3, 5));
	printf("%f\n", float_max(3.0, 5.0));

	return 0;

7.命名约定

把宏名全部⼤写
函数名不要全部⼤写(如get_number或者GetNumber)

尽管ANSI C中没有严格要求，但这是一个约定俗成的风格，建议大家遵守

8.undefin

这条指令⽤于移除⼀个宏定义

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

9.命令行定义(博主没办法演示)

许多C的编译器提供了⼀种能⼒，允许在命令⾏中定义符号。⽤于启动编译过程。
例如：
当我们根据同⼀个源⽂件要编译出⼀个程序的不同版本的时候，这个特性有点⽤处。（假定某个程序中声明了⼀个某个⻓度的数组，如果机器内存有限，我们需要⼀个很⼩的数组，但是另外⼀个机器内存⼤些，我们需要⼀个数组能够⼤些。）

10.条件编译

在编译⼀个程序的时候我们如果要将⼀条语句（⼀组语句）编译或者放弃是很⽅便的。因为我们有条件编译指令。

1.#if 常量表达式
//…
#endif
//常量表达式由预处理器求值。
如：
#define DEBUG 1
#if DEBUG
//…
#endif
2.多个分⽀的条件编译
#if 常量表达式
//…
#elif 常量表达式
//…
#else
//…
#endif
3.判断是否被定义
#if defined(symbol)
#ifdef symbol
#if !defined(symbol)
#ifndef symbol
#if 常量表达式
//…
#endif
//常量表达式由预处理器求值。
如：
#define DEBUG 1
#if DEBUG
//…
#endif
2.多个分⽀的条件编译
#if 常量表达式
//…
#elif 常量表达式
//…
#else
//…
#endif
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
可以注意到在头文件中运用了大量这样的语句

11.头文件的包含

11.1本地文件

11.2库文件的包含

11.3 嵌套文件的包含

我们已经知道， #include 指令可以使另外⼀个⽂件被编译。就像它实际出现于 #include 指令的地⽅⼀样。
这种替换的⽅式很简单：预处理器先删除这条指令，并⽤包含⽂件的内容替换。
⼀个头⽂件被包含10次，那就实际被编译10次，如果重复包含，对编译的压⼒就⽐较⼤。

 #ifndef __TEST_H__
 #define __TEST_H__

 int Add(int x,int y);

 struct S
 {
     char c;
     int i;
 };
 #endif

我们最先包含头文件时未定义__TEST_H__就会执行下面的语句，再次包含时已经定义了__TEST_H__后面的语句在包含时就注释了（删除），当然我们也可以在相应的头文件中用一下预处理指令。

#pragma once

12.其他预处理指令

#error
#pragma
#line
…
#pragma pack()在结构体部分介绍。(改变默认对其量的)

13.总结

以上就是C语言的所有基础知识，满打满算学习了三个月的C语言知识。写了两个月的博客吧，写博客怎么说能一直在进步吧。但是总感觉自己写的也还不是很好，而且博客要写的东西也比较多，而且一直都在补前面的过程。怎么说呢，降低预期，保持努力吧。本来也不是科班的学生，甚至本专业没开设任何相关的课程狠狠地学环境，还是感谢大家的关注。我也不多想付出的努力一定会有相应的回报吧，因为这确实是我的兴趣所在。倘若我的博客能帮助到你，这就是对我最大的鼓励了。当然后面也会继续更新C语言的练习，还有数据结构，C++等等的知识。我也会优化自己博客的内容，给大家带来高质量的作品
心怀热爱,奔赴山海