做网站i3够用吗搜索引擎推广的方法有

内容提要

• 预处理

• 库文件

预处理

C语言编译步骤

1. 预处理

2. 编译

3. 汇编

4. 链接

什么是预处理

预处理就是在源文件（.c文件）编译之前，所进行的一部分预备操作，这部分操作是由预处理程序自动完成。当源文件在编译时，编译器会自动调用预处理程序来完成预处理执行的操作，预处理执行解析完成才能进入下一步的编译过程

查看预处理结果：

 gcc 源文件 -E -o 程序名[.后缀]

预处理功能

宏定义（可以使用宏定义完成无符号常量的创建）

• 不带参数的定义

  • 语法：

     #define 宏名称 常量数据

  • 预处理机制：此时的预处理只做数据替换，不做类型检查

  • 注意：宏定义不会占用内存空间，因为在编译前已经将宏名替换成了常量数据

  • 宏展开：在预编译时将宏名替换成字符串的过程称之为“宏展开”（将宏名替换成常量数据的过程）

  • 案例：

     #define PI 3.1415926​int main(){float l,s,r,v;printf("请输入圆的半径：\n");scanf("%f",&r);// 计算周长l = 2.0 * PI * r;// 计算面积s = PI * r * r;printf("l=%10.4f\ns=%10.4f\n",l,s);return 0;}

• 带参数的宏定义

  • 语法：

     #define 宏名(参数列表) 参数表达式

  • 面试题：

     #define multi(a,b) (a) * (b)#define multi(a,b) a * b

    实现：

     // 定义一个带参数的宏，带参数的宏名为小写#define multi_1(a,b) (a) * (b)#define multi_2(a,b) a * b​int main(){int result1 = multi_1(7+2,3); // (a)*(b) = (7+2)*3 = 27printf("%d\n",result1); // 27int result2 = multi_2(7+2,3); // a * b = 7+2 * 3 = 13printf("%d\n",result2); // 13return 0;}

• 宏定义的作用域：

  • #define命令出现在程序中函数的外面，宏名的有效范围为定义命令之后到本源文件结束

  • 可以用#undef命令终止宏定义的作用域

  • 案例：

     #define PI 3.14  // PI的作用域 10行 ~ 18行#define DAY 28   // DAY的作用域 11行 ~ 文件末尾​void func1(){float r = 4;float s = PI * r * r;int day = DAY;}#undef PI // 终止了PI的范围​#define PI 3.1415926​void func2(){float r = 4;float s = PI * r * r;int day = DAY;}​int main(int argc, char *argv[]){func1();func2();return 0;}

• 在宏定义中引用已定义的宏名

  • 案例：

     #define R 3.0       // 半径#define PI 3.14  #define L 2 * PI * R   // 在宏定义中引用已定义的宏名#define S PI * R * R​#define P_WIDTH 800#define P_HEIGHT 480#define SIZE P_WIDTH * P_HEIGHT​int main(int argc, char *argv[]){printf("L=%f\nS=%f\n",L,S);return 0;}

文件包含

概念

所谓“文件包含”处理是指一个源文件可以将另一个源文件的全部内容包含进来。这适用于多文件开发。通常，一个常规的C语言程序会包含多个源码文件（*.c），当某些公共资源需要在各个源码文件中使用时，为了避免多次编写相同的代码，我们一般会进行代码的抽取（*.h），然后在各个源码文件中直接包含即可

注意：*.h中的函数声明必须要在*.c中有对应的函数定义（函数的实现），否则没有意义。（函数一旦声明，就一定要定义）

头文件（.h）的内容

头文件中所存放的内容，就是各个源码文件的彼此可见的公共资源，包括：

• 全局变量的声明

• 普通函数的声明

• 静态函数的定义

• 宏定义

• 结构体、共用体的定义

• 枚举常量列表的定义

• 其他头文件包含

示例代码：

 // head.h​extern int global;    // 全局变量的声明extern void func1();  // 普通函数的声明static void func2();  // 静态函数的声明，写在.h中，引用此文件的.c文件直接调用；写在.c，只能这个.c文件访问{...}#define max(a,b) ((a)>(b)?(a):(b)) // 宏定义​struct node          // 结构体定义{...};​union attr           // 共用体定义{...};​enum SEX             // 枚举常量列表定义{...};​#include <stdio.h>   // 系统头文件#include "myhead.h"  // 自定义头文件

特别说明：

1. 全局变量、普通函数的定义一般出现在某个源文件（*.c,*.cpp）中，其他源文件想要使用都需要进行声明，因此一般放在头文件中更方便

2. 静态函数、宏定义、结构体、联合体的定义都只能在其所在的文件可见，因此如果多个源文件都需要的话，放到头文件中定义是最方便的选择

预处理机制：将文件中的内容替换文件包含指令

包含方式

1. #include <xxxx.h>：系统会到标准库文件目录（Linux下/usr/include）查找包含的文件，建议对于系统库访问采用这种写法

2. #include "xxxx.h"：在当前工程路径下（Linux下./）查找包含的文件，如果未找到，就去标准库文件目录下查找。建议对于自定义库采用这种写法

案例

myhead.h

 #ifndef _MYHEAD_H#define _MYHEAD_H​/*** 数组的累加和运算* @param int* int数组* @param int 数组大小*/extern int sum(const int*, int)#endif // _MYHEAD_H

myhead.c

 #include <stdio.h>#include "myhead.h"​/*** 数组的累加和运算（定义）*/int sum(const int *arr, int len){const int *p = arr;int sum = 0;for(; p < arr + len; p++){sum += *p;}return sum;}

app.c

 #include <stdio.h>#include "myhead.h"​int main(int argc, char *argv[]){int arr[] = {11,12,13,14,15};int result = sum(arr,sizeof(arr)/sizeof(arr[0]));printf("数组累加和的结果是：%d\n",result);return 0;}

多文件编译命令：

 gcc app.c myhead.c -o app

条件编译

定义：根据设定的条件选择待编译的语句代码

预处理机制：将满足条件的语句进行保留，将不满足条件的语句进行删除，交给下一步编译

语法：

• 语法一：

  根据是否找到标识，来决定是否参与编译（标识存在为真）

   #ifdef 标识   // 判断标识符定义与否，定义为真，未定义为假（找到标识符为真①，找不到为假②）... ①#else... ②#endif

• 语法二：

  根据是否找到标识，来决定是否参与编译（标识不存在为真）

   #ifndef 标识   // 判断标识符定义与否，未定义为真，定义为假（找不到标识符为真①，找不到为假②）... ①#else... ②#endif

• 语法三：

  根据表达式的结果，来决定是否参与编译（表达式成立为真1，不成立为假0）

   #if 表达式   // 判断表达式结果，成立为1，不成立为0... ①#else... ②#endif

案例：

 #include <stdio.h>​#define LETTER 0 // 默认是大写​int main(int argc,char *argv[]){// 测试用的字母字符串char str[20] = "C Language";char c;int i = 0;// 遍历获取每一个字符while((c = str[i])!='\0'){#if LETTERif(c >= 'a' && c <= 'z'){c -= 32;}#elseif(c >= 'A' && c <= 'Z'){c += 32;}#endifprintf("%c",c);i++;}printf("\n");return 0;}

避免头文件重复包含的方法

其实就是头文件去重复

由于头文件包含指令#include的本质是复制粘贴，并且一个头文件中可以嵌套包含其他头文件，因此很容易出现头文件被重复包含的文件。此时就需要我们进行去重，去重需要用到预处理提供的去重相关的指令

语法：

 #ifndef _XXXX_H  // 一般为 下划线+头文件名大写+下划线+H#define _XXXX_H..#endif

案例：

 #ifndef _MYHEAD_H#define _MYHEAD_H​/*** 数组的累加和运算* @param int* int数组* @param int 数组大小*/extern int sum(const int*, int);#endif // _MYHEAD_H

库文件

什么是库文件

库文件本质上是经过编译后生成的可被计算机执行的二进制代码，但注意库文件不能独立运行，库文件需要加载到内存中才能执行。库文件大量存在于Windows、Linux、MacOS等软件平台上

库文件的分类

• 静态库

  • Windows：xxx.lib

  • Linux：libxxxx.a

• 动态库（共享库）

  • Windows：xxx.dll

  • Linux：libxxxx.so.major.minor

注意：不同的软件平台因为编译器、链接器不同，所生成的库文件是不兼容的

静态库与动态库的区别

1. 静态库链接时，将库中所有内容包含到最终的可执行程序中

2. 动态库链接时，将库中的符号信息包含到最终可执行程序中，在程序运行时，才将动态库中符号的具体实现加载到内存中

静态库与动态库的优缺点

1. 静态库

   • 优点：生成的可执行程序不再依赖静态库文件

   • 缺点：可执行程序体积较大

2. 动态库

   • 优点：生成的可执行程序体积小；动态库可被多个语言程序共享

   • 缺点：可执行程序运行依赖动态库文件

库文件的创建

Linux系统下库文件命名规范：libxxxx.a（静态库）libxxxx.so（动态库）

静态库文件的生成

1. 将需要生成库文件对应的源文件（*.c）通过编译（不链接）生成（*.o）目标文件

2. 用ar命令将生成的*.o打包生成libxxxx.a

库的生成：

库的使用：

动态库文件的生成

1. 利用源文件（*.c）通过编译（不链接）生成*.o目标文件

2. 将目标文件链接为*.so文件

库的生成：

库的使用：

注意：如果在代码编译过程或者运行中链接了库文件，系统会到/lib和/usr/lib目录下查找库文件，所以建议直接将库文件放置在/lib或者/usr/lib，否则系统可能无法找到库文件，造成编译或者运行错误

扩展

1. 查看应用程序（例：app）依赖的动态库

2. 动态库使用方式：

   • 编译时链接动态库，运行时系统自动加载动态库

   • 程序运行时，手动加载动态库

   • 实现：

     • 涉及内容：

       • 头文件：#include <dlfcn.h>

       • 接口函数：dlopen、dlclose、dlsym

       • 依赖库：-ldl

       • 句柄handler：资源的标识

     • 示例代码：

        #include <stdio.h>#include <dlfcn.h>​int main(int argc,char *argv[]){// 1. 加载动态库 "/lib/libdlfun.so"//    - RTLD_LAZY: 延迟绑定（使用时才解析符号，提高加载速度）//    - 返回 handler 是动态库的句柄，失败时返回 NULLvoid* handler = dlopen("/lib/libdlfun.so", RTLD_LAZY);if (handler == NULL){// 打印错误信息（dlerror() 返回最后一次 dl 相关错误的字符串）fprintf(stderr, "dlopen 失败: %s\n", dlerror());return -1;}// 2. 从动态库中查找符号 "sum"（函数名）//    - dlsym 返回 void*，需强制转换为函数指针类型 int sum(int *arr, int size);//    - 这里假设 "sum" 是一个接受两个int*,int参数、返回 int 的函数int (*paddr)(int*, int) = (int (*)(int*, int))dlsym(handler, "sum");if (paddr == NULL){fprintf(stderr, "dlsym 失败: %s\n", dlerror());dlclose(handler); // 关闭动态库（释放资源）return -1;}​// 3. 调用动态库中的函数 "sum"，计算{11,12,13,14,15}的累加和int arr[5] = {11,12,13,14,15};printf("sum=%d\n", paddr(arr, sizeof(arr)/sizeof(arr[0])));// 4. 关闭动态库（释放内存和资源）dlclose(handler);return 0;}

     • 编译命令

        gcc demo06.c -ldl