Linux文件编程和库的制作

linux目录及文件操作

linux文件目录分布

常用的Linux指令：

vi编辑器

vi是一种方便的代码编辑器，Linux系统一般是自带的

linux文件

-rw-rw-r-- 1 cc cc   41 May  2 06:53 1q
-rw-rw-r-- 1 cc cc   13 May  2 05:53 a.c
-rw-rw-r-- 1 cc cc   42 May  2 06:54 add.c
-rw-rw-r-- 1 cc cc 1232 May  2 06:54 add.o
-rw-r--r-- 1 cc cc  363 May  2 05:31 cat.c
-rwxrwxr-x 1 cc cc 8656 May  2 02:04 demo

1.open函数

//包含的头文件：
#include <sys/types.h>//这里提供类型pid_t和size_t的定义
#include <sys/stat.h>
#include <fcntl.h>

int open(const char *pathname, int flags); /*比较常用*/
int open(const char *pathname, int flags, mode_t mode);

const char *file_path = "/home/user/test.txt";

// 以只读模式打开文件
int fd1 = open("/home/user/test.txt", O_RDONLY);

// 如果文件不存在则创建它，以读写模式打开
int fd2 = open("/home/user/new_file.txt", O_RDWR | O_CREAT, 0666);

#include <unistd.h>//包含的头文件

int close(int fd);

#include <unistd.h>

ssize_t write (int fd,const void * buf, size_t count);

#include <unistd.h>

ssize_t read(int fd, void *buf, size_t count);

int main(int argc,char *argv[])
{
return 0;
}

下面实现cp指令来理解main函数的参数：

编写demo.c:

include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
int main(int argc,char *argv[])
{
        int src_fd;
        int des_fd;
        char sendBuffer[128]={0};
        int ByteNum = 0;

        src_fd =  open(argv[1],O_RDWR);
        if(src_fd < 0)
        {
                printf("open file %d failed\n",src_fd);
                return -2;

        }

        des_fd =  open(argv[2],O_RDWR|O_CREAT,0755);
        if(des_fd <0)
        {
                printf("open file %d failed\n",des_fd);
                return -1;
        }

        while(1)
        {


                ByteNum = read(src_fd,&sendBuffer[0],128);

                if(ByteNum<128)
                        break;
                write(des_fd,&sendBuffer[0],ByteNum);
                memset(sendBuffer,0,128);
        }

        write(des_fd,sendBuffer,ByteNum);
        close(src_fd);
        close(des_fd);
        return 0;
}

此时在命令行编译demo.c生成可执行文件a.out后

在命令行输入./a.out demo.c demo1.c即可实现cp demo.c demo1.c 的效果

此时main函数的参数argc的值为3，数组argv[0]存放的是./a.out,argv[1]存放的是demo.c,argv[2]存放的是demo1.c

5.lseek函数

off_t lseek(int fd, off_t offset, int whence);//设置光标偏移量

文件IO和标准IO

概念层面

• 文件 I/O：也被称为低级 I/O 或者系统调用 I/O，它直接使用操作系统提供的系统调用来进行文件操作，如在 Unix/Linux 系统中的 open、read、write、lseek 和 close 等函数。这些系统调用是操作系统内核的一部分，提供了对文件最基本的访问方式。
• 标准 I/O：又称为高级 I/O，它是基于 C 标准库实现的一套文件操作接口，如 fopen、fread、fwrite、fseek 和 fclose 等函数。标准 I/O 库对底层的文件 I/O 系统调用进行了封装，提供了更方便、更高级的文件操作功能。

缓冲机制

• 文件 I/O：通常是无缓冲或者使用内核缓冲。无缓冲意味着每次调用 read 或 write 函数时都会直接进行系统调用，与磁盘或其他设备进行数据交互，这可能会导致频繁的系统调用，从而影响性能。内核缓冲由操作系统内核管理，应用程序无法直接控制。
• 标准 I/O：使用用户空间的缓冲区，标准 I/O 库会在内存中为每个文件流分配一个缓冲区。当调用 fread 或 fwrite 函数时，数据会先被读写到缓冲区中，只有当缓冲区满或者调用 fflush 函数时，才会将缓冲区中的数据实际写入磁盘或从磁盘读取数据到缓冲区。这种缓冲机制可以减少系统调用的次数，提高 I/O 性能。

可移植性

• 文件 I/O：不同的操作系统提供的文件 I/O 系统调用可能有所不同，因此使用文件 I/O 编写的代码可移植性较差。例如，Windows 系统和 Unix/Linux 系统的文件 I/O 接口存在差异。
• 标准 I/O：C 标准库定义了一套统一的标准 I/O 接口，这些接口在不同的操作系统和编译器上具有较好的可移植性。只要是支持 C 标准库的系统，都可以使用标准 I/O 函数进行文件操作。

错误处理

• 文件 I/O：文件 I/O 系统调用通常通过返回值和 errno 变量来进行错误处理。返回值可以表示操作的结果，如 open 函数返回 -1 表示打开文件失败，而 errno 变量可以进一步指示具体的错误类型。
• 标准 I/O：标准 I/O 函数通常通过返回值来表示操作的结果，如 fopen 函数返回 NULL 表示打开文件失败。同时，标准 I/O 库还提供了 ferror 和 feof 等函数来检查文件流的错误和结束状态。

操作灵活性

• 文件 I/O：文件 I/O 提供了对文件操作的底层控制，例如可以直接设置文件偏移量、指定读写的字节数等，适合对文件进行底层的、精细的操作。
• 标准 I/O：标准 I/O 提供了更高级的功能，如格式化输入输出（fprintf 和 fscanf）、行缓冲等，适合进行更方便、更复杂的文件操作。

#include "stdio.h"
int main()
{
char buf[]="hello linux";
printf("%s",buf);
while(1);
return 0;
}

此时buf的内容不会打印到显示器上面

6.fopen函数

fopen fwrite fread fclose ... 属于标准C库，都具有缓冲机制

   函数原型

 #include <stdio.h>

 FILE *fopen(const char *pathname, const char *mode);
/*
* @description : 打开一个文件
* @param ‐ pathname : 指定文件路径,如："./test.txt"
* @param ‐ mode ：指定文件的打开方式，如下：
* @return : 成功，返回指向该文件的文件指针; 若失败，返回 NULL
*/

参数说明：

第一个参数为欲打开文件的文件路径及文件名，第二个参数表示对文件的打开方式

返回值：

文件打开了，返回一个指向该打开文件的指针(FILE结构)；文件打开失败，错误上存errorcode(错误代码)

mode有以下值：

r：只读方式打开，文件必须存在

r+：可读写，文件必须存在

rb+：打开二进制文件，可以读写

rt+:打开文本文件，可读写

w:只写，文件存在则文件长度清0，文件不存在则建立该文件

w+:可读写，文件存在则文件长度清0，文件不存在则建立该文件

a:附加方式打开只写，不存在建立该文件，存在写入的数据加到文件尾，EOF符保留

a+：附加方式打开可读写，不存在建立该文件，存在写入的数据加到文件尾，EOF符不保留

wb：打开二进制文件，只写 wb+:打开或建立二进制文件，可读写

wt+:打开或建立文本文件，可读写

at+:打开文本文件，可读写，写的数据加在文本末尾 ab+:打开二进制文件，可读写，写的数据加在文件末尾

7.fread函数

从文件中读取数据到指定地址中

#include <stdio.h>

size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
/*
* @description :对已打开的流进行数据读取
* @param ‐ ptr ：指向 数据块的指针
* @param ‐ size ：指定读取的每个数据项的字节数
* @param ‐ nmemb : 指定要读取的数据项的个数
* @param ‐ stream ：要读取的文件流
* @return : 返回实际读取数据项的个数;
*/

参数说明：

第一个参数为接收数据的指针(buff),也即数据存储的地址

第二个参数为单个元素的大小，即由指针写入地址的数据大小，注意单位是字节

第三个参数为元素个数，即要读取的数据大小为size的元素个素

第四个参数为提供数据的文件指针，该指针指向文件内部数据

返回值：

读取的总数据元素个数

8.fwrite函数

#include <stdio.h>

size_t fwrite(const void *ptr, size_t size, size_t nmemb,FILE *stream);

/*
* @description :对已打开的流进行写入数据块
* @param ‐ ptr ：指向 数据块的指针
* @param ‐ size ：指定写入的每个数据项的字节数，如调用sizeof(char)
* @param ‐ nmemb :指定写入的数据项的个数
* @param ‐ stream ：要写入的文件流
* @return : 返回实际写入的数据项的个数
*/

fread()──从fp所指向文件的当前位置开始，一次读入size个字节，重复nmemb次，并将读入的数据存放 到从buffer开始的内存中； buffer是存放读入数据的起始地址（即存放何处）

fwrite()──从buffer开始，一次输出size个字节，重复nmemb次，并将输出的数据存放到fp所指向的文件 中。buffer是要输出数据在 内存中的起始地址（即从何处开始输出）

一般用于二进制文件的处理

9.fseek函数

重定位文件内部的指针

int fseek(FILE *stream,long offset,int framewhere)

参数：第一个为文件指针，第二个是指针的偏移量，第三个是指针偏移起始位置

返回值：重定位成功返回0，否则返回非零值

说明：执行成功，则stream指向以fromwhere为基准，偏移offset个字节的位置。执行失败(比方说offset偏移的位 置超出了文件大小)，则保留原来stream的位置不变

起始位置：

SEEK_SET 既0 文件开头

SEEK_CUR 既1 文件当前位置

SEEK_END 既2 文件结尾

例如：

1. fseek(fp,100L,SEEK_SET);把fp指针移动到离文件开头100字节处；

2. fseek(fp,100L,SEEK_CUR);把fp指针移动到离文件当前位置100字节处；

3. fseek(fp,-100L,SEEK_END);把fp指针退回到离文件结尾100字节处。

10.fclose函数

关闭一个文件流，使用fclose就可以把缓冲区内最后剩余的数据输出到磁盘文件中，并释放文件指针和有关 的缓冲区

#include <stdio.h>

int fclose(FILE *stream);

/*
* @description :关闭一个已打开的流
* @param ‐ stream :文件指针（流）
* @return : 成功，返回0; 若失败，返回EOF
*/

11.fgets和fputs

char *fgets (char *s, int size,FILE *stream)

第一个参数：缓存，即读到哪里去

第二个参数：读多少个字节

第三个参数：从什么地方读

返回值：若成功则为s（缓存的地址），若已处文件尾端或出错则为null

int fputs(const char *s,FILE *stream);

第一个参数：缓存，即写什么内容

第二个参数：写到哪里去

返回值：若成功则为非负值，若出错则为EOF -1 

gets 与fgets的区别：

gets()时不能指定缓存的长度，这样就可能造成缓存越界（如若该行长于缓存长度），写到缓存之后的存储空间中，从而产生不可预料的后果；

gets()只能从标准输入中读；

gets()与fgets()的另一个区别是:gets()并不将新行符存入缓存中, fgets 将新行符存入缓存中;

puts 与fputs的区别：

puts()只能向标准输出中写；

puts()与fputs()的另一个区别是: puts 输出时会添加一个新行符，fputs不会添加；

12.刷新缓存函数

把库函数中的缓存内容强制写到内核中。

ffluash（FIFE *fp）

13.调整读写位置指针函数

fseek()参数与lseek是一样的但是返回值不一样

lseek的返回值是：当前文件的位置指针值；

fseek()的返回值是：成功返回0，失败返回-11；

rewind(FILE *fp) 用于设定流的文件位置指示为文件开始，该函数调用成功无返回值。

rewind()等价于(void)fseek(fp 0, SEEK_SET)；

ftell(FILE *fp) 用于取得当前的文件位置，调用成功则为当前文件位置指示，若出错则为-1L；

14.fprintf、printf、sprintf

int fprintf(FILE *stream,”字符串格式”)

fprintf可以输出到文件中，也可输出到显示器，

printf 只能输出到显示器中。

intsprintf(str *, “字符串格式”) 输出内容到一个字符串中

15.fgetc和fputc

int fgetc(FILE *fp)

功能：从文件中读取一个字符；

参数：文件流

返回值：正确为读取的字符，到文件结尾或出错时返回EOF。

int fputc(int c, FILE *fp)

功能：写一个字符到文件中

参数：第一个参数为要写的字符，第二个参数为文件流

返回值：成功则返回输入的字符，出错返回EOF。

int feof(FILE *stream)

功能：判断是否已经到文件结束

参数：文件流

返回值：到文件结束，返回为非0，没有则返回0

int ferror(FILE *stream);

功能：判断是否读写错误

参数：文件流

返回值：是读写错误，返回为非0，不是则返回0

void clearerr(FILE *stream);

功能：清除流错误

参数：文件流

实现cat指令

#include <stdio.h>


int main(int argc,char *argv[])
{

        FILE*fp;
        int nRet = 0;

        if(argc != 2)
        {
                printf("failed\n");
                return -1;
        }

        fp = fopen(argv[1],"r");
        if(fp == NULL)
        {
                printf("open file failed\n");
                return -2;

        }
        while(1)
        {

                nRet = fgetc(fp);
                if(feof(fp))
                {
                        break;
                }
                fputc(nRet,stdout);

        }
        fclose(fp);

        return 0;
}

编译后在命令行输入./a.out cat.c 即可实现cat cat.c 的效果

静态库和动态库

静态库，libxxx.a，在编译时就将库编译进可执行程序中。

优点：程序的运行环境中不需要外部的函数库，运行速度快

缺点：可执行程序大

动态库，又称共享库，libxxx.so，在运行时将库加载到可执行程序中。

优点：可执行程序小。

缺点：程序的运行环境中必须提供相应的库，运行速度慢

函数库目录：/lib /usr/lib

静态库的制作

1.创建库文件

gcc -c mylib.c -o mylib.o
ar rcs libmylib.a mylib.o 

#1.先用.c文件生成.o文件
#2.再用.o文件生成静态库libxxx.a

  

  2.使用库文件 

gcc main.c -o main -L. -lmylib 
./main 

#1.-l是指定要用的静态库，库名去掉头尾 -L是让gcc从-L指定的路径找，-L.是当前工作目录
#2.运行可执行文件

动态库的制作

1.生成目标文件

gcc -c file.c

2.生成libaddsub.so 动态函数库

gcc -shared -fpic -o libfile.so file.o

‐fpic：产生位置无关代码
‐shared：指定生成动态库

3.使用库文件

gcc main.c -o out ‐L. ‐lfile

此时还不能立即./out，因为在动态函数库使用时，会查找/usr/lib /lib目录下的动态函数库，而此时我们生成的库不在里边

解决办法：

方法一：直接放入法

把libaddsub.so放到/usr/lib 或/lib中去

sudo cp /path/to/libaddsub.so /usr/lib/

#将 /path/to/ 替换为实际路径（例如 ./libaddsub.so 表示当前目录）
#使用 sudo 确保有足够权限修改 /usr/lib

2.更新动态链接库缓存

sudo ldconfig

方法二：环境变量法（临时）

  通过环境变量 LD_LIBRARY_PATH 临时指定（当前终端有效）

  输入以下命令：

export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:/path/to/your/library" 
 
#将 /path/to/your/library 替换为动态库所在实际路径

方法三：通过修改 /etc/ld.so.conf 文件

1.编辑配置文件

sudo nano /etc/ld.so.conf

2.在文件末尾添加一行，内容为你动态库所在的目录路径

/opt/mylibs  # 添加此行（替换为实际库目录）

3.更新动态链接库缓存

sudo ldconfig