2024年大数据最新c语言进阶篇：带你全方面学习程序环境和预处理，2024年最新成功入职网易月薪35K-CSDN博客

本文链接：https://blog.csdn.net/2401_84160361/article/details/138630367

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

#define MAX 1000;
#define STP “hello”
#define print printf(“hehe\n”);
int main()
{
int m = MAX;
printf(“%d\n”, MAX);
printf(“%s\n”, STP);
print;
return 0;
}


![在这里插入图片描述](https://img-blog.csdnimg.cn/0adae6f05bbb411dbd64264d5d26c298.png)  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/4b7b0203624c41ed8329ba2bb396cf65.png)


#### ✏️#define定义宏


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


宏的申明方式 :#define name( parament-list ) stuff其中的 parament-list 是一个由逗号隔开的符号表，它们可能出现在stuff中。


注意：  
 **参数列表的左括号必须与name紧邻。  
 如果两者之间有任何空白存在，参数列表就会被解释为stuff的一部分。**

#include <stdio.h>
#define SQUARE( x ) x * x
int main()
{
int r = SQUARE(5);
//r = 5*5;
//这里存在缺陷：
int a = SQUARE(5+1);
//认为是：a = (5+1)*(5+1)?错误，由替换产生的表达式并没有按照预想的次序进行求值
//a = 5+1*5+1 = 11
//在宏定义上加上两个括号，这个问题便轻松的解决了：
return 0;
}

#define SQUARE(x) ((x)*(x))
int main()
{
int r = SQUARE(5);
int s = SQUARE(5 + 1);
printf(“%d\n”, r);
printf(“%d\n”, s);
return 0;
}


![在这里插入图片描述](https://img-blog.csdnimg.cn/f8c8af8d484c4d8bb67dea6de6828353.png)  
 这里有一个问题：宏定义要不要把整体括号括起来？我们来看一段代码：

#include <stdio.h>
#define DOUBLE(x) (x)+(x)
int main()
{
int r = 10 * DOUBLE(3);
printf(“%d\n”, r);
return 0;
}


![在这里插入图片描述](https://img-blog.csdnimg.cn/994fb4d7844f475eb0f8c5c6c3e30226.png)  
 结果为33，那如果整体有括号呢？

#include <stdio.h>
#define DOUBLE(x) ((x)+(x))
int main()
{
int r = 10 * DOUBLE(3);
printf(“%d\n”, r);
return 0;
}


![在这里插入图片描述](https://img-blog.csdnimg.cn/c18cbe65383140b28a8e787ffb541230.png)  
 **所以用于对数值表达式进行求值的宏定义都应该用这种方式加上括号，避免在使用宏时由于参数中的操作符或邻近操作符之间不可预料的相互作用。**


#### ✏️#define替换规则


在程序中扩展#define定义符号和宏时，需要涉及几个步骤：


1. 在调用宏时，首先对参数进行检查，看看是否包含任何由#define定义的符号。如果是，它们首先 被替换。
2. 替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被他们的值所替换。
3. 最后，再次对结果文件进行扫描，看看它是否包含任何由#define定义的符号。如果是，就重复上 述处理过程。


注意：


1. 宏参数和#define 定义中可以出现其他#define定义的符号。但是对于宏，不能出现递归。
2. 当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被搜索。


#### ✏️#和##两个预处理的工具


如何把参数插入到字符串中？

#include<stdio.h>
int main()
{
char* p = “hello ““world\n”;
printf(“hello”” world\n”);
printf(“%s”, p);
return 0;
}


![在这里插入图片描述](https://img-blog.csdnimg.cn/a0ca4c5f1962477e93bd9a288684d2cd.png)  
 字符串是有自动连接的特点的。

#define PRINT(FORMAT, VALUE)
printf(“the value is “FORMAT”\n”, VALUE);
…
PRINT(“%d”, 10);


这里只有当字符串作为宏参数的时候才可以把字符串放在字符串中。  
 另外一个技巧是：  
 使用 # ，把一个宏参数变成对应的字符串。

#include<stdio.h>
#define PRINT( NAME, TYPE) printf(“the value of “#NAME” is “TYPE”\n”,NAME);
int main()
{
double a = 4.0;
PRINT(a, “%lf”);
int b = 10;
PRINT(b, “%d”);
return 0;
}


![在这里插入图片描述](https://img-blog.csdnimg.cn/213020fdfb2d4a439513bd2d76a0b80f.png)  
 **##可以把位于它两边的符号合成一个符号。 它允许宏定义从分离的文本片段创建标识符。**

#include<stdio.h>

#define CAT(X,Y) X##Y

int main()
{
int class101 = 100;
printf(“%d\n”, CAT(class, 101));
printf(“%d\n”, class101);
return 0;
}


![在这里插入图片描述](https://img-blog.csdnimg.cn/e4cc4652b2b14a958c0129d8452a194e.png)


#### ✏️带副作用的宏参数


![在这里插入图片描述](https://img-blog.csdnimg.cn/06bd71ea015c451e82a974c8b3b3800c.png)  
 当宏参数在宏的定义中出现超过一次的时候，如果参数带有副作用，那么你在使用这个宏的时候就可能 出现危险，导致不可预测的后果。副作用就是表达式求值的时候出现的永久性效果。


例如：


x+1;//不带副作用


x++;//带有副作用


![在这里插入图片描述](https://img-blog.csdnimg.cn/446738ef3fd54b0e8fd547ee9394b1f7.png)


#### ✏️宏和函数的优缺点对比


![在这里插入图片描述](https://img-blog.csdnimg.cn/a53bf9120b5f45698e3ea5ce21b6c45b.png)  
 **宏有时候可以做函数做不到的事情。比如：宏的参数可以出现类型，但是函数做不到。**

#define MALLOC(num, type) (type*)malloc((num)*sizeof(type))
#include<stdio.h>
int main()
{
//malloc(40);
//malloc(10, int);
int*p = MALLOC(10, int);
//int* p = (int*)malloc((10) * sizeof(int));

return 0;

}


#### ✏️命名约定


一般来讲函数的宏的使用语法很相似；所以语言本身没法帮我们区分二者。


那我们平时的一个习惯是：


把宏名全部大写


函数名不要全部大写


### 🎉#undef


这条指令用于移除一个宏定义。


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


![在这里插入图片描述](https://img-blog.csdnimg.cn/3ddd887ce1df4a359617721a0191f2a5.png)


### 🎉命令行定义


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

#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


### 🎉条件编译


常见的条件编译指令：

#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


### 🎉文件包含


#include 指令可以使另外一个文件被编译；就像它实际出现于 #include 指令的地方一样。


这种替换的方式很简单：


预处理器先删除这条指令，并用包含文件的内容替换。


这样一个源文件被包含10次，那就实际被编译10次。


#### ✏️头文件包含


本地文件包含

#include “filename”


库文件包含

#include <filename.h>


使用<>和“ ”文件包含的区别  
 <> ：直接去库目录(标准路径)下查找， 如果该头文件未找到 ，提示编译错误。  
 " " ：先去代码所在的路径下查找，如果该头文件未找到，再去库目录(标准路径)下查找，如果找不到，提示编译错误。


#### ✏️嵌套文件包含


![在这里插入图片描述](https://img-blog.csdnimg.cn/5d8bfb138ce14126bf59629388dba325.png)  
 如果出现这样的场景


comm.h和comm.c是公共模块。


test1.h和test1.c使用了公共模块。


test2.h和test2.c使用了公共模块。


test.h和test.c使用了test1模块和test2模块。

//每个头文件的开头写：

#ifndef __TEST_H__

#define __TEST_H__

//头文件的内容

#endif //__TEST_H__

//或者：