C语言05 - 文件操作 预处理命令

Posted 2022-12-08 李樟清

1. 文件操作

文件分为两部分： 控制信息 和 内容信息
文本文件 和 图片 本质上都是 二进制文件，只是控制信息 不同而已
读文件的流程： 磁盘（得到二进制文件）》 文件缓冲区》应用程序内存空间

在widows看到的各种各样的文件比如jpg，png，avi各种不同类型的文件只是在 从磁盘读到文件缓冲区的时候他会根据文件的控制信息进行相应的编解码

C语言 二进制文件和文本文件读写的区别：
二进制：写文本 ‘\\n’-> \\r\\n
二进制：读文本 \\r\\n -> \\n

1. read 文件、写文件

read文件
int main()

    char *path = "G:\\\\0_preClass\\\\NDK\\\\class\\\\Ls_C5\\\\files\\\\friends.txt";

    FILE *fp = fopen(path, "r");

    char buff[500];
    while (fgets(buff, 50, fp))
    
        printf("%s", buff);
    

    fclose(fp);
    system("pause");
    return 0;

/写文件//
int main() 

    char *path = "G:\\\\0_preClass\\\\NDK\\\\class\\\\Ls_C5\\\\files\\\\friends_write2.txt";
    // 如果不存在，会创建
    FILE *fp = fopen(path, "w");

    if (fp == NULL) 
        printf("failed。。。。");
        return 0;
    

    char *text = "你好，WTF？";
    fputs(text, fp);
    fclose(fp);


    system("pause");
    return 0;

2. 读写 二进制文件

///读写二进制文件
int main() 
    char * read_path = "G:\\\\0_preClass\\\\NDK\\\\class\\\\Ls_C5\\\\files\\\\LogViewPro.exe";
    char * write_path = "G:\\\\0_preClass\\\\NDK\\\\class\\\\Ls_C5\\\\files\\\\LogViewPro_write.exe";

    //read ：rb 的b是以二进制的形式，没有b就是以文本的形式
    FILE * read_fp = fopen(read_path, "rb");
    //write
    FILE * write_fp = fopen(write_path, "wb");
    char buff[50];
    int len = 0;
    // 从read_fp里面读每次50个sizeof(char)大小的文件
    while ((len = fread(buff, sizeof(char), 50,  read_fp)) != 0) 
    
        fwrite(buff, sizeof(char), len, write_fp);
    
    fclose(read_fp);
    fclose(write_fp);
    system("pause");
    return 0;

3. size of the file

int main() 
    char *read_path = "G:\\\\0_preClass\\\\NDK\\\\class\\\\Ls_C5\\\\files\\\\liuyan.png";

    FILE *fp = fopen(read_path, "r");
    if (fp == NULL)
    
        return 0;
    
    // 设置流 stream 的文件位置为给定的偏移 offset，参数 offset 意味着从给定的 whence 位置查找的字节数。
    fseek(fp, 0, SEEK_END);
    // 返回给定流 stream 的当前文件位置。
    long  filesize = ftell(fp);

    printf("%ld \\n", filesize);

    system("pause");
    return 0;

4. 文本文件加解密

// ^ 异或运算 7(0111)
// 1001 ^ 0111 = 1110
// 1110 ^ 0111 = 1001 

void encode(char normal_path[], char encode_path[]) 
    FILE * normal_fp = fopen(normal_path, "r");
    FILE * encode_fp = fopen(encode_path, "w");

    int ch;
    while ((ch = fgetc(normal_fp)) != EOF)
        fputc(ch ^ 7, encode_fp);
    
    fclose(normal_fp);
    fclose(encode_fp);


void decode(char encode_path[], char decode_path[]) 
    FILE * normal_fp = fopen(encode_path, "r");
    FILE * encode_fp = fopen(decode_path, "w");

    int ch;
    while ((ch = fgetc(normal_fp)) != EOF) 
        fputc(ch ^ 7, encode_fp);
    
    fclose(normal_fp);
    fclose(encode_fp);


int main() 
    char * nomal_path = "G:\\\\0_preClass\\\\NDK\\\\class\\\\Ls_C5\\\\files\\\\friends.txt";
    char * encode_path = "G:\\\\0_preClass\\\\NDK\\\\class\\\\Ls_C5\\\\files\\\\friends_encode.txt";
    char * decode_path = "G:\\\\0_preClass\\\\NDK\\\\class\\\\Ls_C5\\\\files\\\\friends_decode.txt";
    //encode(nomal_path, encode_path);
    decode(encode_path, decode_path);
    system("pause");
    return 0;

2. 预处理命令

预处理命令：
首先要了解C语言的执行流程，C 语言首先将主程程序的各个元文件（.c .cpp）通过编译生成.obj ，生成之后，然后将各个目标文件obj文件由链接器捆绑起来，形成一个库（exe文件 pdb dll so）

而在生成.obj 的时候又会有两个过程，第一个就是预处理器阶段（把源文件上面的可执行文件进行一些#define #include全部读进来）

说明: #include 就是在预处理阶段 运行的，就是文本的替换

1. 小示例

A.txt 文件

printf("hello WTF? \\n");

#include <stdlib.h>
#include <string.h>

//#define  标识符  字符串
// 字符串替换
// typedef 别名
#define MAX(x, y) ((x) > (y)) ? x: y

#define M

int main() 
    #include "A.txt"

    for (int i = 0; i < 5; i++)
    
        printf("%d \\n", i);
    

    int max = MAX(3, 5);
    printf("%d \\n", max);
#ifdef N
#ifdef M
    printf("%d \\n", 110);
#else 
    printf("%d \\n", 120);
#endif

#endif

#ifndef X
    printf("%d \\n", 130);

#endif
    system("pause");
    return 0;

2. 详细说明

预处理指令
C 语言执行的流程：
一，  组成程序的每个源文件通过编译过程分别转换成目标代码(object code)
二，  各目标文件由连接器 捆绑在一起，形成一个单一而完整的可执行文件

而编译过程又由如下过程组成：
1.  预处理器处理，在这个阶段，预处理器在源代码上执行一些文本操作。例如：用实际值代替由 #define指令定义的符号以及读入由#include指令包含的文件的内容。
2.  源代码经过解析，判断它的语句的意思，这个阶段会产生绝大多数错误和警告信息的地方，随后便生成目标代码。

执行阶段：
1.  程序必须载入到内存中。
2.  程序执行
3.  程序执行的最后一个阶段就是程序终止。


Define指令的作用
无参宏定义
#define  标识符  字符串
定义常量
意义：就是宏替换的作用，让 标识符替换 字符串，这只是一种简单的文本替换，预处理程序对它不作任何检查。如有错误，只能在编译已被宏展开后的源程序时发现。
反例
#define pint（int*）
pint pa, pb;
  本意是定义pa和pb均为int型指针，但实际上变成int* pa,pb;。pa是int型指针，而pb是int型变量。本例中可用typedef来代替define，这样pa和pb就都是int型指针了。因为宏定义只是简单的字符串代换，在预处理阶段完成，而typedef是在编译时处理的，它不是作简单的代换，而是对类型说明符重新命名，被命名的标识符具有类型定义说明的功能

无参宏注意事项：
•   宏名一般用大写字母表示，以便于与变量区别。
•   宏定义末尾不必加分号，否则连分号一并替换。
•   宏定义可以嵌套。
•   可用#undef命令终止宏定义的作用域。
•   使用宏可提高程序通用性和易读性，减少不一致性，减少输入错误和便于修改。如数组大小常用宏定义。
•   预处理是在编译之前的处理，而编译工作的任务之一就是语法检查，预处理不做语法检查。
•   宏定义写在函数的花括号外边，作用域为其后的程序，通常在文件的最开头。
•   字符串" "中永远不包含宏，否则该宏名当字符串处理。
•   宏定义不分配内存，变量定义分配内存。
带参宏定义
#define宏名（参数） 字符串

例如：
#define INC(x) x+1
y = INC(5);

反例：
#define SQ(r ) r*r
Y = SQ(a+b); 结果= a+b*a+b;

使用案例：
我们最常用的一种替代方案区最大最小值：
#define MAX(x,y)   (((x) > (y)) ? (x): (y))


文件包含

文件包含命令把指定头文件插入该命令行位置取代该命令行，从而把指定的文件和当前的源程序文件连成一个源文件。
在程序设计中，文件包含是很有用的。一个大程序可以分为多个模块，由多个程序员分别编程。有些公用的符号常量或宏定义等可单独组成一个文件，在其它文件的开头用包含命令包含该文件即可使用。这样，可避免在每个文件开头都去书写那些公用量，从而节省时间，并减少出错。


#include <> 或者 #include “” 区别
< > 和 “ ” 区别在于： 使用《》 表示在包含文件目录中去查找 （包含目录是由用户在设置环境时设置的include 目录“解决方案管理器 -> 属性-> 配置属性 -> VC++ 目录”），而不是在当前源文件目录去寻找； 使用双引号就是先从当前源文件目录中查找。

条件编译
第一种方式
#ifdef 标识符 （或者#if defined）
程序段1
#else 
程序段2
#endif
或者
#ifdef 标识符 （或 #if defined 标识符）
程序段
#endif


第二种方式
#ifndef
 #else
#endif

第三种方式
#if
#else
#endif

在实践中的作用：
1.  屏蔽跨平台差异
在大规模开发过程中，特别是跨平台和系统的软件里，可以在编译时通过条件编译设置编译环境。
#ifdef WINDOWS
     #define MYTYPE long
#else
     #define MYTYPE float
#endif

2.  包含程序功能模块
#ifdef FLV
    Include “fastleavec”
#endif
当不许向别的用户提供该功能，则在编译之前将首部的FLV 加一下横线即可

3.  开关调试信息
#ifdef DEBUG
     Prinft(“device_open (%d)\\n”, file);
#endif
   这个DEBUG 就是一个开关。可以在整个工程的一个公用的头文件中，当我们处于debug 阶段的时候就将这个开关打开，当我们程序release 版本里面的时候就将这个开关关闭。

4.  避开硬件的限制
有时一些具体的应用环境的硬件不同，但限于条件本地缺乏这种设备，可绕过硬件直接写出预期结果：
#ifndef TEST
   I  =  dial();
#else 
   I = 0;
#endif

5.  防止头文件重复包含
头文件可以被头文件或者C文件包含。由于头文件包含可以嵌套，C文件就有可能多次包含同一个文件； 或者不同的C文件都包含同一个头文件，编译时就可能出现重复包含的问题。
#ifndef  HEAD_A
#define HEAD_A
     #include <>
#endif