库的制作与原理(一)

news2025/2/23 8:16:43

·1.库的概念

库是写好的，现成的可以复用的代码。本质上库是一种可执行的二进制形式，可以被操作系统载入内存执行。库有俩种：静态库 .a[Linux] .lib[windows] 动态库 .so[Linux] .dll[windows]

就是把.c文件变成.o文件，把许多的.o文件一起打包成.a或者.so。

需要用到的代码

my_stdio.h

#pragma once
#define SIZE 1024

#define FLUSH_NONE 0
#define FLUSH_LINE 1
#define FLUSH_FULL 2

struct IO_FILE
{
        int flag;//刷新方式
        int fileno;//文件描述符
        char outbuffer[SIZE];
        int cap;
        int size;
};

typedef struct IO_FILE mFILE;

mFILE* mfopen(const char* filename,const char* mode);
int mfwirte(const void* ptr,int num,mFILE* stream);
void mfflush(mFILE* stream);
void mfclose(mFILE* stream);

my_stdio.c

#include"my_stdio.h"
#include<string.h>
#include<stdlib.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>



mFILE* mfopen(const char* filename,const char* mode)
{
        int fd=-1;
        if(strcmp(mode,"r")==0)
        {
                fd=open(filename,O_RDONLY);
        }
        else  if(strcmp(mpde,"w")==0)
        {

                fd=open(filename,O_CREAT|O_WRONLY|O_TRUNC,0666);
        }
        else if(strcmp(mode,"a")==0)
        {
                fd=open(filename,O_CREAT|O_WRONLY|O_APPEND,0666);
        }
        if(fd<0)
        {
                return NULL;
        }
        mFILE* mf=(mFILE*)malloc(sizeof(mFILE));
        if(!mf)
        {

                close(fd);
                return NULL;
        }

        mf->fileno=fd;
        mf->flag=FLUSH_LINE;
        mf->size=0;
        mf->cap;
        return mf;


}

void mfflush(mFILE* stream)
{
        if(stream->size>0)
        {
                //写到内核文件的缓冲区中
                write(stream->fileno,steam->outbuffer,stream->size);
                //用fsync函数稳定刷新到外设
                fsync(stream->fileno);
                stream->size=0;


        }

}

int mfwrite(const void* ptr,int num,mFILE* stream)
{
        memcpy(stream->outbuffer+stream,ptr,num);
        stream->size+=num;
        //检查是否更新
        if(stream->flag==FLUSH_LINE&&stream->size>0&&stream->outbuffer[stream->size-1]=='\n')
        {
                mfflush(stream);
        }
        return num;



}

void mfclose(mFILE* stream)
{
        if(stream->size>0)
        {
                mfflush(stream);
        }
        close(stream->fileno);


}

my_string.h

#pragma once

int my_strlen(const char* s);

my_string.c


#include"my_string.h"

int my_strlen(const char* s)
{
        const char* end=s;
        while(*end!='\0')end++;
        return end-s;
}

fsync 函数是 POSIX 标准中定义的一个函数，用于将文件描述符指向的文件的数据强制写入到磁盘上。这个函数确保了所有缓冲区中的数据都被写入到磁盘，并且磁盘上的数据是最新的。这对于需要确保数据持久化的应用场景非常重要，例如数据库、日志文件等。

2.静态库

静态库(.a)：程序在编译链接的时候把库的代码链接到可执行文件中，程序运行时将不再需要静态库。

一个可执行程序可能用到许多库，这些库运行有的是静态库，有的是动态库，而我们编译默认认为动态链接库，只有在该库找不到动态.so的时候才会采用同名静态库。可以使用gcc的-static强转设置链接静态库。

静态库的生成

makefile文件

libmystdio.a:my_stdio.o my_string.o
        @ar -rc $@ $^
        @echo "bulid $^ to  $@"



%.o:%.c
        @gcc -c $<
        @echo "compling $< to $@"

.PHONY:clean
clean:
        @rm -rf *.a *.o stdc*


.PHONY:output
output:
        @mkdir -p stdc/include
        @mkdir -p stdc/lib
        @cp -f *.h stdc/include
        @cp -f *.a stdc/lib
        @tar -czf stdc.tgz stdc

ar是gun归档工具，rc表示replace and create

静态库的使用

#include "my_stdio.h"
#include "my_string.h"
#include <stdio.h>
int main()
{
        const char *s = "abcdefg";
        printf("%s: %d\n", s, my_strlen(s));
        mFILE *fp = mfopen("./log.txt", "a");
        if(fp == NULL) return 1;
        mfwrite(s, my_strlen(s), fp);
        mfwrite(s, my_strlen(s), fp);
        mfwrite(s, my_strlen(s), fp);
        mfclose(fp);
        return 0;
}
~

场景一：头文件和库文件安装到系统默认路径下时

指令：gcc main.c -lmystdio

场景二：头文件和库文件和源文件在同一路径下时

指令：gcc main.c -L. -lmymath

场景三：头文件和库文件有自己的独立路径

gcc main.c -I头文件路径 -L库文件路径 -lmymath（链接库的名称）

注意：库的名称要去掉前面的lib和后缀才是名字

3.动态库

动态库(.so)：程序在运行时的时候才去链接动态库的代码，多个程序共享使用库的代码。

一个与动态库链接的可执行文件仅仅包含它用到的函数入口地址的一个表，而不是外部函数所在目标文件的整个机械码。

动态库可以在多个程序间共享，所以动态链接使得可执行文件更小，节省了磁盘空间，操作系统采用虚拟内存机制允许物理内存中的一份动态库被要用到该库的所有1进程共享，节省了内存和磁盘空间。

动态库的生成


libmystdio.so:my_stdio.o my_string.o
        @gcc -o $@ $^ -shared
        @echo "bulid $^ to  $@"



%.o:%.c
        @gcc -fPIC -c $<
        @echo "compling $< to $@"

.PHONY:clean
clean:
        @rm -rf *.so *.o stdc*


.PHONY:output
output:
        @mkdir -p stdc/include
        @mkdir -p stdc/lib
        @cp -f *.h stdc/include
        @cp -f *.so stdc/lib
        @tar -czf stdc.tgz stdc

shared:表示生成共享库格式

fPIC:产生位置无关码(position independent code)

库名规则：libxxx.so