C语言基础第21天：预处理与文件操作详解

预处理

预处理功能

条件编译

概念

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

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

语法：

        语法1：根据是否找到标记，来决定是否参与编译（标记存在为真，不存在为假）

#ifdef 标记 // 标记 一般使用宏定义
... 语句代码1
#else
... 语句代码2
#endif

        说明： printf("调试模式！\n"); 和 printf("调试模式！\n"); 只能保留一个。 undef 取消已定义的宏（使其变为未定义状态）

#define DEBUG 1 // 定义宏
#undef DEBUG // 取消定义的宏
#ifdef DEBUG
    printf("调试模式！\n"); // 删除
#else
    printf("产品模式！\n"); // 保留
#endif

        语法2： 根据是否找到标记，来决定是否参与编译（标记不存在为真，存在为假）

#ifndef 标记
... 语句代码1
#else
... 语句代码2
#endif

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

// 单分支
#if 表达式
... 语句代码1
#endif
// 双分支
#if 表达式
... 语句代码1
#else
... 语句代码2
#endif
// 多分支
#if 表达式1
... 语句代码1
#elif 表达式n
... 语句代码n
#else
... 语句代码n+1
#endif

文件包含

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

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

基本语法

标准库包含（使用尖括号）（会到/usr/include目录下查找）

#include <stdio.h> // 包含标准输入输出库 会到/usr/include目录下查找
#include <stdlib.h> // 包含标准库函数

自定义文件包含（使用双引号）（会先在当前目录下查找，找不到再到/usr/include目录下查找）

#include "myheader.h" // 包含当前目录下的自定义头文件
#include "utils/tool.h" // 包含子目录下的头文件

// 在myheader.h中
#ifndef MYHEADER_H // _MYHEADER_H, __MYHEADER_H
#define MYHEADER_H
... 头文件内容
#endif

#pragma once
... 头文件内容

库文件

什么是库文件

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

库文件的分类

• 静态库
  • windows：xxx.lib
  • linux：libxxxx.a
• 动态库（共享库）
  • windows：xxx.dll
  • linux：libxxxx.so.major.minor (libmy.so.1.1)

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

静态库与动态库的区别

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

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

静态库与动态库的优缺点

1. 静态库

• 优点：生成的可执行程序不再依赖静态文件
• 缺点：可执行程序体积较大

2. 动态库

• 优点：生成的可执行程序体积小；动态库可被多个应用程序共享
• 缺点：可执行程序运行依然依赖动态库文件

静态库与动态库对比

库文件创建

Linux系统下库文件的命名规范： libxxx.a (静态库) libxxxx.so (动态库)

静态库文件的生成

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

2. 用 ar 命令将生成的 *.o 打包生成 libxxx.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 是动态库的句柄，失败时返回 NULL
    void* 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;
}

文件I/O

文件基础概念

FILE *fp; // 声明文件指针

#include <stdio.h>
FILE *fopen(const char *path, const char *mode);

#include <stdio.h>
int fclose(FILE *fp);

#include <stdio.h>
#include <stdlib.h>
int main()
{
    // 打开文件
    FILE *fp = fopen("texst.txt","w");
    if (!fp)
    {
        perror("打开文件失败！");
        return -1; // exit(1);
    }
    // 读写文件
    // 关闭文件
    if(fclose(fp) != 0)
    {
        perror("关闭文件失败！");
        return -1;
    }

    return 0;
}

int fgetc(FILE *fp);

int fputc(int c, FILE *fp);

#include <stdio.h>
char* fgets(char *buf, int size, FILE *fp);

int fputs(const char *str, FILE *fp);