server.c

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include "doublyList.h"
#include 
#include "array.h"
myListOP * fdList;


int isSameAddr(void* a,void*b){
    return a-b;
}
int isSameInt(int* a,int*b){
    return *a-*b;
}



struct info{
    struct sockaddr_in client_addr;
    int fd;
    struct epoll_event* event;
    myListOP* record;
};

int* getfd(struct info* info){
    return &(info->event->data.fd);
}




struct patientRecord
{
    time_t time;
    char patientName[40];
    char patientRec[128];
    char doctorDia[128];
    char tablet[128];
    char doctorAdv[128];
    //size=4*128+4+40=556
};
struct patientRecord * createPatinetRecord(time_t time,char* patientName,
                        char* patientRec,char* doctorDia,char* tablet,char* doctorAdv){
                           struct patientRecord * ret = malloc (sizeof (struct patientRecord));
                           ret->time = time;
                           if (patientName)
                           {
                            strcpy(ret->patientName,patientName);
                           }
                           strcpy(ret->patientRec,patientRec);
                           strcpy(ret->doctorDia,doctorDia);
                           strcpy(ret->tablet,tablet);
                           strcpy(ret->doctorAdv,doctorAdv);
                           return ret;
                        }
enum enum_send_t{
    send_record =1,
    read_record,
};
struct send_t
{
    enum enum_send_t type;
    struct patientRecord patientRecord;
};
static void printRec(struct patientRecord* rec){
    char timeStr[64]; // 用于存储格式化后的时间字符串
    strftime(timeStr, sizeof(timeStr), "%Y-%m-%d %H:%M:%S", localtime(&rec->time));
    printf("%s::
 病人描述:%s
, 医生诊断:%s
, 开药:%s
, 医嘱:%s
",
           timeStr, rec->patientRec, rec->doctorDia, rec->tablet, rec->doctorAdv);
}
static void printSend_t(struct send_t* send){
    if (send->type == send_record)
    {
        printf("send_record
");
    }
        if (send->type == read_record)
    {
        printf("read_record
");
    }

    printRec(&send->patientRecord);
}

struct info* creatInfo(struct sockaddr_in *client_addr,int fd,struct epoll_event* event){
    struct info* ret = malloc(sizeof(struct info));
    ret->record = myListDInit(printSend_t);
    if (client_addr)
    {
        ret->client_addr=*client_addr;
    }
    else{
        memset(&ret->client_addr,0,sizeof(struct sockaddr_in));
    }
    ret->event = event;
    ret->fd = fd;
    return ret;
}
void printInfo(struct info* info){
    static char ip_human[16] = {0};
    if (info ==0 || (&(info->client_addr)==0))
    {
        return;
    }
    
    int port_human=ntohs(info->client_addr.sin_port);
    inet_ntop(AF_INET,&info->client_addr.sin_addr,ip_human,16);
    printf("ip:%s,port:%d,fd:%d::",ip_human,port_human,info->fd);
}

sqlite3* db;

int mysqlite3_append(struct patientRecord* rec){
    char sql[1024]="";
    sprintf(sql,"create table if not exists %s (
        日期 INTEGER ,
        病人口述 TEXT,
        医生诊断 TEXT,
        医生开药 TEXT,
        医嘱 text 
        );", rec->patientName);
    char ** result;
    char * errmsg;
    int ret = 0;
    ret=sqlite3_exec(db,sql,0,0,&errmsg);
    if (ret)
    {
        //sql执行一场
        printf("在添加表格时出现异常:: %s
",errmsg);
        return EXIT_FAILURE;
    }
    sprintf(sql,"insert into %s (日期,病人口述,医生诊断,医生开药,医嘱)
        values (%ld,'%s','%s','%s','%s');",
        rec->patientName,rec->time,rec->patientRec,rec->doctorDia,rec->tablet,rec->doctorAdv);
    ret=sqlite3_exec(db,sql,0,0,&errmsg);
    if (ret)
    {
        //sql执行一场
        printf("在添加数据时出现异常:: %s
",errmsg);
        return EXIT_FAILURE;
    }
    return 0;
}
int callback (myListOP* list,int argc, char ** argv,char** col){
    // for (int i = 0; i < argc; i++)
    // {
    //     /* code */
    // }

    list->append(list,createPatinetRecord(atol(argv[0]),0,argv[1],
                argv[2],argv[3],argv[4]));
    return 0;
    
}
int mysqlite3_read(struct patientRecord * rec,myListOP* list){
    char sql[1024]="";
    
    sprintf(sql,"create table if not exists %s (
        日期 INTEGER ,
        病人口述 TEXT,
        医生诊断 TEXT,
        医生开药 TEXT,
        医嘱 text 
        );", rec->patientName);
    char ** result;
    char * errmsg;
    int ret = 0;
    ret=sqlite3_exec(db,sql,0,0,&errmsg);
    if (ret)
    {
        //sql执行一场
        printf("在添加表格时出现异常:: %s
",errmsg);
        return EXIT_FAILURE;
    }
    sprintf(sql,"select * from %s ;", rec->patientName);
    ret=sqlite3_exec(db,sql,callback,list,&errmsg);
    if (ret)
    {
        //sql执行一场
        printf("在添加数据时出现异常:: %s
",errmsg);
        return EXIT_FAILURE;
    }
    return 0;
}
int serverfun(struct info* info){
    int client = info->fd;
    char ip_human[16]={0};
    int port_human=0;
    struct sockaddr_in client_addr = {0};
    client_addr = info->client_addr;
    inet_ntop(AF_INET,&client_addr.sin_addr,ip_human,16);
    port_human=ntohs(client_addr.sin_port);
    char buf[560] = "";
    int res = read(client,buf,sizeof(unsigned short int));
    int size = *(unsigned short int*)buf;
    if (res == 0)
    {
        printf("客户端已断开连接:
IP:%s
port:%d
",ip_human,port_human);
        close(client);
        fdList->del(fdList,fdList->find(fdList,info,0));
        return 0;
    }
    res = read(client,buf+sizeof(unsigned short int),size-sizeof(unsigned short int));
    myListOP * tmp =0;
    tmp = info->record->unpack(info->record,buf,printRec);
    info->record->destory(info->record);
    info->record=tmp;
    struct send_t * st = 0;
    unsigned int i=0;
    while (st = info->record->slice(info->record,i++))
    {
        if (st->type == send_record)
        {
            mysqlite3_append(&st->patientRecord);
        }
        if (st->type == read_record)
        {
            myListOP* list = myListDInit(printRec);
            mysqlite3_read(&st->patientRecord,list);
            while (list->packed == 0)
            {
                res = list->pack(list,buf,560,sizeof(struct patientRecord));
                send(info->fd,buf,res ,0);
            }
            list->destory(list);
        }
        
    }
    return 1;
}
void printEvent(struct epoll_event event){
    printf("fd:%d,ptr:%p-->",event.data.fd,event.data.ptr);
}

int main(int argc, char const *argv[])
{
    if (argc<2)
    {
        printf("请输入端口号
");
        return 1;
    }
    
    int server = socket(AF_INET,SOCK_STREAM,0);
    sqlite3_open("/home/mr-oy/c-codes/数据库/hospital.db",&db);
    struct sockaddr_in addr={0};
    addr.sin_family=AF_INET;
    addr.sin_port=htons(atoi(argv[1]));
    addr.sin_addr.s_addr=inet_addr("0.0.0.0");

    if(bind(server,(struct sockaddr * )&addr,sizeof(addr))==-1){
        perror("bind:");
        return 1;
    }
    struct sockaddr_in client_addr = {0};
    int client_len = sizeof(client_addr);

    int ret;
    int max = 10;
    listen(server,max);
    char ip_human[16]="";
    int port_human = 0;
    //创建监视列表
    int epoll_handler = epoll_create1(EPOLL_CLOEXEC);
    // 将服务器加入到handeler内
    struct epoll_event serverEvent;
    serverEvent.events=EPOLLIN|EPOLLET;
    serverEvent.data.fd=server;
    epoll_ctl(epoll_handler,EPOLL_CTL_ADD,server,&serverEvent);

    int client;
    fdList = myListDInit((void(*)(void*))printInfo);
    struct info * currentinfo=0;
    struct epoll_event* currentevent=0;
    int* currentfd =0;
    unsigned int i=0;

    // fdList->append(fdList,creatInfo(0,server,&serverEvent));
    myArrayOP* eventList = myArrayInit(20,sizeof(struct epoll_event),printEvent);

    printf("服务器正在运行:
");
    for (;;)
    {
        i=0;
        memset(eventList->data,0,eventList->max_length*eventList->size);
        eventList->length = epoll_wait(epoll_handler,eventList->data,eventList->max_length,-1);
        while (currentevent = (struct epoll_event*)eventList->slice(eventList,i++))
        {
            currentfd = &(currentevent->data.fd);
            if (*currentfd == server)//有新的客户端连接
            {
                client = accept(server,(struct sockaddr * )&client_addr,&client_len);
                struct epoll_event* clientevent = malloc(sizeof(struct epoll_event)) ;
                memset(clientevent,0,sizeof(struct epoll_event));
                clientevent->data.fd=client;
                clientevent->events=EPOLLIN|EPOLLET;
                fdList->append(fdList,creatInfo(&client_addr,client,clientevent));
                epoll_ctl(epoll_handler,EPOLL_CTL_ADD,client,clientevent);
                inet_ntop(AF_INET,&client_addr.sin_addr,ip_human,16);
                port_human=ntohs(client_addr.sin_port);
                printf("客户端已连接:
IP:%s
port:%d
",ip_human,port_human);
                //将该fd添加到epoll
                continue;;
            }
            //客户端操作
            else if (*currentfd != server)
            {
                unsigned int index= fdList->findby(fdList,isSameInt,getfd,currentfd,0);
                // fdList->print(fdList);
                currentinfo = fdList->slice(fdList,index);
                serverfun(currentinfo);
            }
            
        }
        
        
        

    }  
    return 0;
}

client.c

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include "doublyList.h"
#include "array.h"
struct patientRecord
{
    time_t time;
    char patientName[40];
    char patientRec[128];
    char doctorDia[128];
    char tablet[128];
    char doctorAdv[128];
    //size=4*128+4+40=556
};
enum enum_send_t{
    send_record =1,
    read_record,
};
struct send_t
{
    enum enum_send_t type;
    struct patientRecord patientRecord;
};

struct send_t * createSend_t(enum enum_send_t type,time_t time,char* patientName,
                        char* patientRec,char* doctorDia,char* tablet,char* doctorAdv){
                           struct send_t * st = malloc (sizeof (struct send_t));
                           st->type = type;
                           struct patientRecord *ret = &st->patientRecord;
                           memset(ret,0,sizeof(struct patientRecord));
                           ret->time = time;
                           strcpy(ret->patientName,patientName);
                           if (patientRec !=0)
                           {

                            strcpy(ret->patientRec,patientRec);
                            strcpy(ret->doctorDia,doctorDia);
                            strcpy(ret->tablet,tablet);
                            strcpy(ret->doctorAdv,doctorAdv);
                           }
                           
                           return st;
                        }

static void printRec(struct patientRecord* rec){
    char timeStr[64]; // 用于存储格式化后的时间字符串
    strftime(timeStr, sizeof(timeStr), "%Y-%m-%d %H:%M:%S", localtime(&rec->time));
    printf("%s::
 病人描述:%s
, 医生诊断:%s
, 开药:%s
, 医嘱:%s
",
           timeStr, rec->patientRec, rec->doctorDia, rec->tablet, rec->doctorAdv);
}
static void printSend_t(struct send_t* send){
    if (send->type == send_record)
    {
        printf("send_record
");
    }
        if (send->type == read_record)
    {
        printf("read_record
");
    }

    printRec(&send->patientRecord);
}
int main(int argc, char const *argv[])
{
    if (argc<3)
    {
        printf("请输入端口号
");
        printf("请输入模式
");
        return 1;
    }
    char patientName[40];
    char patientRec[128];
    char doctorDia[128];
    char tablet[128];
    char doctorAdv[128];

    
    myListOP* list = myListDInit(printSend_t);

    int clinet = socket(AF_INET,SOCK_STREAM,0);
    struct sockaddr_in addr={0};
    addr.sin_family=AF_INET;
    addr.sin_port=htons(atoi(argv[1]));
    addr.sin_addr.s_addr=inet_addr("127.0.0.1");

    char buf[560] = {0};
    int used =0;

    if(connect(clinet,(struct sockaddr*)&addr,sizeof(addr))==-1){
        perror("connect:");
        return 1;
    }
    if (strcmp(argv[2],"-u"))
    {
    for (;;)
    {
        
        printf("请输入病人姓名
");
        scanf(" %s",patientName);
        printf("请输入病人自述
");
        scanf(" %s",patientRec);
        printf("请输入医生诊断
");
        scanf(" %s",doctorDia);
        printf("请输入药物
");
        scanf(" %s",tablet);
        printf("请输入医嘱
");
        scanf(" %s",doctorAdv);

        list->append(list,createSend_t(send_record,time(NULL),
        patientName,patientRec,doctorDia,tablet,doctorAdv
        ));
        used = list->pack(list,buf,560,560);
        write(clinet,buf,used);
    }  
    }
    else{
    for (;;)
    {
        
        printf("请输入病人姓名
");
        scanf(" %s",patientName);
        list->append(list,createSend_t(read_record,0,
        patientName,0,0,0,0
        ));
        used = list->pack(list,buf,560,560);
        write(clinet,buf,used);
        while (1)
        {
            used = read(clinet,buf,sizeof(unsigned short int));//理论上会卡死在这行,回头优化
            int size = *(unsigned short int*)buf;
            used = read(clinet,buf+sizeof(unsigned short int),size-sizeof(unsigned short int));
            myListOP * tmp =0;
            tmp = myListDUnpack(0,buf,printRec);
            tmp->print(tmp);
        }
        
        
        
        
    }  
    }
    
    
    return 0;
}

依赖:
doublyLIst.c

#include "doublyList.h"
#include 
#include 
#include 
static int isNull(myListOP * self){
    return self==0 || self->data==0;//头的位置是空,则为null
}
static int isEmpty(myListOP * self){
    return self->data->next==0||self->data->data==0;//头的data的指针指向自己则为null
}
static int isNullOrEmpty(myListOP * self){
    return isNull(self)||isEmpty(self);
}
static void* dequeue(myListOP * self){
    void * ret=0;
    if (isNullOrEmpty(self))
    {
        return 0;
    }
    if (self->data->next == self->data) //只有一个的情况下
    {
        self->length--;
        ret = self->data->data;
        self->data->data =0;
        return ret;
    }
    

    myListP head =self->data;
    head->prev->next = head->next;
    head->next->prev=head->prev;
    self->data=head->next;
    ret = head->data;

    self->__head =0; //迭代器重新生成
    self->length--;
    free(head);
    return ret;
}
static void *pop(myListOP * self){
    if (isNullOrEmpty(self))
    {
        return 0;
    }
    void*ret;
    if (self->data->next == self->data) //只有一个的情况下
    {
        self->length--;
        ret = self->data->data;
        self->data->data =0;
        return ret;
    }
    self->length--;
    self->__head=0;//迭代器重新生成
    myListP current=self->data;
    myListP prev=0;
    myListP next=0;
    
    current = current->prev;//定位到尾部
    prev=current->prev;
    next=current->next;

    prev->next=next;
    next->prev=prev;

    ret=current->data;
    current->data=0;
    free(current);
    return ret;
}

static myListP slice (myListOP * self,unsigned int i){
    if (isNullOrEmpty(self)) //判断是否为空
    {
        return 0;
    }
    //期待i在0~.length之间
    //区间分成了三段,0,__index,length,查看i离哪个更近
    unsigned int distanceFromHead = i;
    unsigned int distanceFromTail = self->length - i;
    unsigned int distanceFromCurrent = i - self->__index;
    distanceFromCurrent=distanceFromCurrent>0?distanceFromCurrent:-distanceFromCurrent;
    if (distanceFromHead <= distanceFromTail && distanceFromHead <= distanceFromCurrent)
    {
        //i离头更近，从头开始遍历
        self->__index = 0;
        self->__last = self->data;
        self->__head = self->data;
    }
    else if (distanceFromTail < distanceFromHead && distanceFromTail <= distanceFromCurrent)
    {
        //i离尾更近，从尾开始遍历
        self->__index = self->length - 1;
        self->__last = self->data->prev;
    }
    if (self->__head != self->data)
    {
        self->__index =0;
        self->__last = self->data;
        self->__head=self->data;
    }
    if (i == 0)
    {
        return self->data;
    }
    for ( ; self->__index < i; self->__index++)
    {
        self->__last = self->__last->next;
        if (self->__last == self->__head)
        {
            break;
        }
        
    }
    for (; self->__index > i; self->__index--)
    {
        self->__last = self->__last->prev;
        if (self->__last == self->__head)
        {
            break;
        }
    }
    return self->__last == self->data?0:self->__last;
}
static void* _slice(myListOP * self,unsigned int i){
    // 这里是后实现的,为了避免对内部函数进行重构,未对slice方法进行重命名
    // 实际用户使用的slice应当为_slice
    // 使用的_slice应当为slice
    // 2025/5/9 修复可能的段错误
    myListP obj = slice(self,i);
    return obj?obj->data:obj;
}
static void*del(struct myListOP*self,unsigned int where){
    if (isNullOrEmpty(self))
    {
        return 0;
    }
    if (where == 0)
    {
        return dequeue(self);
    }
    if (where == self->length-1)
    {
        return pop(self);
    }
    
    //存在2个以上的元素
    myListP last=slice(self,where-1);
    myListP current=slice(self,where);
    myListP next=slice(self,where+1);
    void * ret=0;
    last->next=next;
    next->prev=last;
    ret=current->data;
    free(current);
    self->length --;
    self->__head =0;//迭代器重新生成
    return ret;
}
static int _insertHead(struct myListOP*self,void* data){
    if (isNull(self))
    {
        return 0;
    }
    if (self->data->data ==0)
    {
        self->data->data=data;
        self->__head =0;//迭代器
        self->length++;
        return 1;
    }
    myListP current=(myListP) malloc(sizeof(myList));
    current->data=data;
    current->next=self->data;
    current->prev=self->data->prev;
    self->data->prev->next=current;
    self->data->prev=current;
    self->length++;
    // self->data->prev->next=current;
    self->data=current; //迭代器重新生成
    return 1;
}
static int append(struct myListOP*self,void* data){
    if (isNull(self))
    {
        return 0;
    }
    if (self->data->data ==0)
    {
        self->data->data=data;
        self->__head =0;//迭代器
        self->length++;
        return 1;
    }
    
    myListP current=(myListP) malloc(sizeof(myList));
    myListP head = self->data;
    current->data=data;
    current->next=head;
    current->prev=head->prev;
    head->prev->next=current;
    head->prev=current;
    self->__head =0;//迭代器
    self->length++;
    return 1;
}
static int insert(struct myListOP*self,unsigned int where,void* data){
    if (isNull(self))
    {
        return 0;
    }
    if (where ==0 )
    {
        return _insertHead(self,data);
    }
    if (where ==self->length )
    {
        return append(self,data);
    }
    
    myListP last=slice(self,where-1); //最小 where =1
    myListP current=(myListP) malloc(sizeof(myList));
    myListP next=slice(self,where);

    current->data=data;

    current->next=next;
    current->prev=last;
    last->next=current;
    next->prev=current;
    self->__head =0;
    self->length++;
    return 1;
}
static int delAll(struct myListOP*self,unsigned int where){
    void * data = del(self,where);
    if (data)
    {
        free(data);
        return 1;
    }
    return 0;
}

static unsigned int find(struct myListOP*self,void* obj,unsigned int times){
    myListP p =0;
    unsigned int count =0;
    for (unsigned int i = 0; i < -1; i++)
    {
        p=slice(self,i);
        if (p==0)
        {
            break;
        }
        if (p->data==obj)
        {
            if (times == count)
            {
                return i;
            }
            count ++;
        }

    }
    return -1;
}
static unsigned int findby(struct myListOP*self,int(*cmp)(void*,void*),void*(*filed)(void*),void*target,unsigned int times){//cmp应该返回是否是要找的值
    myListP p =0;
    unsigned int count =0;
    for (unsigned int i = 0; i < -1; i++)
    {
        p=slice(self,i);
        if (p==0)
        {
            break;
        }
        if (cmp(filed(p->data),target)==0)
        {
            if (times == count)
            {
                return i;
            }
            count ++;
        }
    }
    return -1;
}
static unsigned int unicNoFree (struct myListOP*self,void*(*field)(void*),long unsigned int size,unsigned int times){
    unsigned int count=0;
    unsigned int ret =0;
    for (unsigned int i = 1; i < self->length; i++)
    {
        count =0;
        for (unsigned int j = i+1; j < self->length; j++)
        {
            if (memcmp(field(slice(self,i)->data),field(slice(self,j)->data),size)==0)
            {
                if (count >= times)
                {
                    self->delNoFree(self,j);
                    j=j-1;
                }
                count=count+1;
                ret = ret+1;
            }
        }
    }
    return ret;
}
static unsigned int unic (struct myListOP*self,void*(*field)(void*),long unsigned int size,unsigned int times){
    unsigned int count=0;
    unsigned int ret =0;
    for (unsigned int i = 1; i < self->length; i++)
    {
        count =0;
        for (unsigned int j = i+1; j < self->length; j++)
        {
            if (memcmp(field(slice(self,i)->data),field(slice(self,j)->data),size)==0)
            {
                if (count >= times)
                {
                    self->del(self,j);
                    j=j-1;
                }
                count=count+1;
                ret = ret+1;
            }
        }
    }
    return ret;
}

static void print(struct myListOP*self){


    // for (unsigned int i = 0; i < self->length; i++)
    // {
    //     self->__str(self->slice(self,i)->data);
    // }
    myListP cur=self->data;
    if (isNullOrEmpty(self))
    {
        return;
    }
    do{
        self->__str(cur->data);
        cur=cur->next;
    }while (cur!=self->data);
    
    printf("
");
}

static void destory (myListOP *self){
    for (unsigned int i = 0; i < self->length; i++)
    {
        self->del(self,0);
    }
    free(self->data);
    self->data=0;
    free (self);
}
static void destoryNoFree (myListOP *self){
    for (unsigned int i = 0; i < self->length; i++)
    {
        del(self,0);
    }
    // free(self->data);
    self->data=0;
    free (self);
}
static void _quickSort(myListOP *self,long int start,long int end,int(*cmp)(void*, void*),void*(*filed)(void*),int reverse){
    if (start < end) {
        void* base = slice(self, start)->data; // 以要进行排序数组第0个元素为base
        int left = start;  // 左指针
        int right = end;   // 右指针

        while (left < right) {
            // 从右向左找，找到比base小的元素
            while (left < right && (cmp(filed(slice(self, right)->data), filed(base)) * reverse) >= 0) {
                right--;
            }
            // 比base小，替换left所在位置的元素
            slice(self, left)->data = slice(self, right)->data;

            // 从左向右找，找到比base大的元素
            while (left < right && (cmp(filed(slice(self, left)->data), filed(base)) * reverse) <= 0) {
                left++;
            }
            // 比base大，替换right所在位置的元素
            slice(self, right)->data = slice(self, left)->data;
        }
        slice(self, left)->data = base; // 将base放到正确的位置

        // 递归排序左右子数组
        _quickSort(self, start, left - 1, cmp,filed ,reverse);
        _quickSort(self, left + 1, end, cmp,filed, reverse);
    }
}
static void quickSort(myListOP *self,int(*cmp)(void*, void*),void*(*filed)(void*),int reverse){
    if (isNullOrEmpty(self))
    {
        return;
    }
    return _quickSort(self,0,self->length-1,cmp,filed,reverse);
}


static unsigned short int mysizeof(char * obj,unsigned short int size,unsigned int i){
    if (obj==0||size==0){return 0;}
    for (; size>1&&*(char*)(obj+size-1) - *(char*)(obj+size-2)==0; size--);//尾地址为obj+size-1
    return size;
}
static unsigned int pack(myListOP *self,char* buf,unsigned int length,unsigned short int max_size){
    return self->packVarLength(self,buf,length,(unsigned short int(*)(void*,unsigned short int ,unsigned int ))mysizeof,max_size);
}
unsigned int packVarLength(myListOP *self,char* buf,unsigned int length,unsigned short (*sizefun)(void* obj,unsigned short int max_size,unsigned int i),unsigned short int max_size){
    //将对象打包成字节流
    unsigned int used=0;
    void* obj=0;
    unsigned short int size=0;
    unsigned short int min_buf_len = sizeof(unsigned short int)*2;
    self->packed=0;
    if (self->pack_use_max_size)
    {
        min_buf_len =  sizeof(unsigned short int)*3;
    }
    if (length<min_buf_len)
    {
        return 0;
    }
    if (isNullOrEmpty(self))
    {
        return 0;
    }
    // 为总大小腾出空间
    used+=sizeof(unsigned short int);
    if (self->pack_use_max_size)
    {
        //如果启用最大大小,则为最大大小腾出空间
        used+=sizeof(unsigned short int);
    }
    //再循环写入每个元素
    while(obj=self->slice(self,self->__lastPacked++)){
        size = sizefun(obj,max_size,self->__lastPacked-1);
        if (self->pack_use_max_size)
        {
            max_size = max_size<size?size:max_size;
        }
        //需要写入的字节数为size+sizeof（unsigned short int）
        //如果写入量超过长度，则返回实际使用量；
        if (used+size+sizeof(unsigned short int)>length)
        {
            *(unsigned short int *)(buf) =used;
            if (self->pack_use_max_size)
            {
                *(unsigned short int *)(buf+sizeof(unsigned short int)) =max_size;
            }
            self->__lastPacked--;//回退计数器
            return used;//未打包完,返回使用量
        }
        //否则则写入大小和数据
        *(unsigned short int *)(buf+used) =size;
        used+=sizeof(unsigned short int);
        memcpy(buf+used,obj,size);
        used+=size;
    }
    self->__lastPacked = 0;//这里说明打包完了
    *(unsigned short int *)(buf) =used;
    if (self->pack_use_max_size)
    {
        *(unsigned short int *)(buf+sizeof(unsigned short int)) =max_size;
    }
    self->packed=1;
    return used;
}
myListOP* myListDUnpack(char pack_use_max_size,char* buf,void(*printData)(void*)){
    unsigned int total = *(unsigned short int *)buf;//协议包的总大小
    if (total<2*sizeof(unsigned short int)+1)//如果比最小的情况还小(一个总大小,一个对象,对象只写入了一个字节)
    {
        return 0;
    }
   
    unsigned int delta=sizeof(unsigned short int);//偏移量,头两个字节是协议包大小
    unsigned int num =0;//总元素数量
    unsigned int maxSize = *(unsigned short int *)(buf+delta);//最大元素的大小,假设第一个最大
    unsigned int currentSize=0;

    //找到要申请的地址的大小
    if (pack_use_max_size)
    {
        maxSize = *(unsigned short int *)(buf+sizeof(unsigned short int));
        delta+=sizeof(unsigned short int);
    }

    // 先获取最大的大小
    while (delta<total)//不会出现等于,最少会写入1字节的obj
    {
        num=num+1;
        currentSize = *(unsigned short int *)(buf+delta);
        if (maxSize<currentSize)
        {
            maxSize = currentSize;
        }
        delta+=currentSize+sizeof(unsigned short int);
    }
    
    delta = sizeof(unsigned short int);
    if (pack_use_max_size)
    {
        delta+=sizeof(unsigned short int);
    }

    //再申请内存
    myListOP* arr = myListDInit(printData);if (arr == 0){return 0;}
    arr->pack_use_max_size=pack_use_max_size;//继承原有的格式
    while (delta<total)//不会出现等于,最少会写入1字节的obj
    {
        void* obj=malloc(maxSize);if (obj == 0){return 0;}
        currentSize = *(unsigned short int *)(buf+delta);
        delta+=sizeof(unsigned short int);
        memset(obj,*(char*)(buf+delta+currentSize-1),maxSize);//以最后一个字节初始化
        memcpy(obj,buf+delta,currentSize);
        delta+=currentSize;
        arr->append(arr,obj);//对链表,存的是对象的地址
    }
    return arr; 
}
static myListOP* unpack(myListOP* self,char* buf,void(*printData)(void*)){
    //兼容层
    return myListDUnpack(self->pack_use_max_size,buf,printData);
}
static int delByAddrNoFree(myListOP *self,void* obj,unsigned int times){
    if (self==0||self->isNullOrEmpty(self)||obj==0)
    {
        return 0;
    }
    do
    {
        unsigned int where = self->find(self,obj,times);
        if (where == -1)
        {
            break;
        }
        self->delNoFree(self,where);
    } while (times--);
    return times;    
}

static int delByAddr(myListOP *self,void* obj,unsigned int times){
    if (self==0||self->isNullOrEmpty(self)||obj==0)
    {
        return 0;
    }
    do
    {
        unsigned int where = self->find(self,obj,times);
        if (where == -1)
        {
            break;
        }
        self->del(self,where);
    } while (times--);
    return times;    
}

static int add(myListOP *self,myListOP *other){
    void* obj =0;
    unsigned int i =0;
    while (obj=other->slice(other,i++))
    {
        self->append(self,obj);
    }
}

static int sub(myListOP *self,myListOP *other){
    int ret =0;
    if (self ==0||other ==0) 
    {
        return ret;
    }
    if (self->isNullOrEmpty(self)||other->isNullOrEmpty(other))
    {
        return ret;
    }
    void* obj_self =0;
    void* obj_other=0;
    unsigned int i =0;
    unsigned int j=0;
    
    while (obj_other=other->slice(other,i++))
    {
        while (obj_self=self->slice(self,j++))
        {
            if (obj_other==obj_self)
            {
                self->delByAddr(self,obj_self,0);
            }
        }
    }
}
myListOP* myListDInit(void(*printData)(void*)){
    myListOP *self = (myListOP *) malloc(sizeof(myListOP));
    if (self ==0)
    {
        return 0;
    }
    bzero(self,sizeof(myListOP));
    //申请头节点
    self->data = (myListP) malloc(sizeof(myList));
    if (self->data ==0)
    {
        return 0;
    }
    self->data->data=0;
    self->data->next=self->data;
    self->data->prev=self->data;
    self->append=append;
    self->del=delAll;
    self->delNoFree = del;
    self->__str=printData;
    self->destory=destory;
    self->find=find;
    self->findby=findby;
    self->insert=insert;
    self->isNullOrEmpty=isNullOrEmpty;
    self->length=0;
    self->slice=_slice;
    self->_slice=slice;
    self->unic=unic;
    self->print=print;
    self->dequeue=dequeue;
    self->pop=pop;
    self->push=(int (*)(struct myListOP*,void* data))append;
    self->queue=(int (*)(struct myListOP*,void* data))append;
    self->quickSort=quickSort;
    self->_quickSort=_quickSort;
    self->destoryNoFree=destoryNoFree;
    self->unicNoFree=unicNoFree;
    self->packVarLength=packVarLength;
    self->pack=pack;
    self->unpack=unpack;
    self->delByAddr = delByAddr;

    return self;
}
    

doublyList.h

#ifndef  __MYDOUBLYLIST_STRUCT__
#define __MYDOUBLYLIST_STRUCT__

/* 双向循环链表,涵盖操作类
*  
* 用法: 需要外部创建结构体或对象,同时准备好该结构体或对象的打印(print)方法
* 请注意:长度从0开始,到length结束
* 推荐以以下方式迭代链表
* while(obj=.slice(,i++))
* 以下划线(_)开头的方法为某一方法的补充,或是低级实现,理想情况下不应当被使用
* 以下划线(__)开头的字段为内部实现依赖的字段,不应当被外界改变
* 在数组的实现中,部分方法依赖于长度(.length),其长度不应当被改变
* 以下操作是合法的
* _slice(0),_slice(length),_slice(-1),_slice(length+1)返回值分别为头数据,尾数据,0,0
* slice(1),slice(length),返回值分别为头尾节点内存的对象.
* 同一个链表操作类操作不同的链表 即op1->fun(op2,agrs) 该结果应该与 op2->fun(op2,agrs) 一致,但无法保证跨链表操作类结果一致

* 如需排序/去重/按字段查找,则需准备字段的方法
* 如需排序,需要提供比较方法
* 
* 初始 myListOP* mylistOP =  myListDInit((void(*)(void*))printData);
* 2025/5/9  修改返回void* 的slice可能段错误的问题
* 2025/5/10 修补编译器提示,增加unicNoFree,增加pack与unpack
* 2025/5/11 补充测试函数,放弃对单向链表的支持,重命名新增NoFree函数
*/
typedef struct myList{

 void * data;
 struct myList * prev;
 struct myList * next;
}myList,* myListP;

typedef struct myListOP{
 myListP data;
 //判断链是否为空,空返回1,非空返回0
 int (*isNullOrEmpty)(struct myListOP*);
 //将obj存放入链表的尾部,成功返回1,失败返回0
 int (*append)(struct myListOP*,void* data);
 /*
 删除链表上的第where个节点,会自动free该节点指向的对象
 returnVal: 0失败,1成功
 */
 int (*del)(struct myListOP*,unsigned int where);
 /*
 删除链表上的第where个节点,会自动free该节点指向的对象
 returnVal: 该节点指向的对象的地址
 */
 void* (*delNoFree)(struct myListOP*,unsigned int where);
 /*
 在where处插入obj对象
 returnVal: 0失败,1成功
 */
 int (*insert)(struct myListOP*,unsigned int where,void* obj);
 /*
 查找该对象times+1次,返回times+1次所对应的下标,times为0表示取第一个
 returnVal: where,-1表示未找到该对象
 */
 unsigned int (*find)(struct myListOP*self,void* obj,unsigned int times);
 /*
 在链表上保证链表上某个对象最多不出现time+1次,会free对象
 field:取字段函数,接受链表内存储的对象,返回要排序的字段的地址
 size:该字段的大小
 具体调用:memcmp(field(slice(self,i)->data),field(slice(self,j)->data),size)==0
 returnVal:删除了几个对象
 */
 unsigned int (*unic)(struct myListOP*self,void*(*field)(void*),long unsigned int size,unsigned int times);
     /*
 在链表上保证链表上某个对象最多不出现time+1次,不会free对象
 field:取字段函数,接受链表内存储的对象,返回要排序的字段的地址
 size:该字段的大小
 具体调用:memcmp(field(slice(self,i)->data),field(slice(self,j)->data),size)==0
 returnVal:删除了几个对象
 */
 unsigned int (*unicNoFree)(struct myListOP*self,void*(*field)(void*),long unsigned int size,unsigned int times);
 /* 
 返回链表内第i个链的地址,不应当被外部调用
 */
 myList* (*_slice)(struct myListOP* self,unsigned int i);
 /* 
 返回链表内第i个对象的地址
 应该被这么用:
 while(obj=op->slice(op,i++)){
 do something to op
 }
 */
 void* (*slice)(struct myListOP* self,unsigned int i);
 // 销毁链表,并且销毁链表内的所有对象(free obj)
 void (*destory)(struct myListOP *self);
 // 将链表内的所有对象挨个传给.__str方法,.__str方法应当在初始化时被正确设置为接受对象的地址并进行输出
 void (*print)(struct myListOP * self);
 /*
 field:取字段函数,接受链表内存储的对象,返回要排序的字段的地址
 cmp: 比较函数,接收target,接受由field产生的字段的地址,返回两个值的差值(cmp(filed(p->data),target))
 target:要比较的值的地址
 times:找第times+1个
 returnVal:找到返回where,没找到返回-1
 */
 unsigned int (*findby)(struct myListOP*self,int(*cmp)(void*,void*),void*(*field)(void*),void*target,unsigned int times);
 //.print会调用这个方法输出链表内的对象(会将每一个对象的地址输入进这个方法)
 void (*__str)(void*);
 //删除链表的第一个节点,将其内部存放的对象的地址返回(而不是free)
 void*  (*dequeue)(struct myListOP* self);
 //删除链表的尾节点,将其内部存放的对象的地址返回(而不是free)
 void*  (*pop)(struct myListOP* self);
 //将obj存放入链表的尾部,成功返回1,失败返回0
 int  (*push)(struct myListOP*,void* obj);
 //将obj存放入链表的尾部,成功返回1,失败返回0
 int  (*queue)(struct myListOP*,void* data);
 //对链表的一部分进行快速排序
 void (*_quickSort)(struct myListOP*self,long int start,long int end,int(*cmp)(void*, void*),void*(*filed)(void*),int reverse);
 //对整个链表快速排序,field:根据对象的哪个字段地址进行排序,cmp接受两个字段的地址,返回两个字段值的差值,reverse为正则正序,为负则倒叙,0不排序
 void (*quickSort)(struct myListOP *self,int(*cmp)(void*, void*),void*(*filed)(void*),int reverse);
 //删除整个链表,但不释放链表中的对象
 void (*destoryNoFree)(struct myListOP*self);
 //按地址删除某一元素,obj要删除的对象,times删除次数,返回实际删除了几次,不释放obj
 int (*delByAddr)(struct myListOP *self,void* obj,unsigned int times);
 /*
 将对象打包成字节流,写入到buf,会删除重复的尾字节
 字节流格式：unsigened short int used（2字节) unsigened short int datalen(2字节) data
 如果.pack_use_max_size != 0,则在used 之后写入该对象的最大大小
 buf:缓冲区,字节流写入的地址
 length:缓冲区buf的长度
 max_size:链表上存储的obj最大的大小(如大小不一致,请使用.packVarLength)
 returnVal:往缓冲区实际写入的字节数
 */
 unsigned int (*pack)(struct myListOP *self,char* buf,unsigned int length,unsigned short int max_size);
 /*
 将对象打包成字节流,写入到buf,会删除重复的尾字节
 字节流格式：unsigened short int used（2字节)unsigened short int datalen(2字节) data
 如果.pack_use_max_size != 0,则在used 之后写入该对象的最大大小
 buf:缓冲区,字节流写入的地址
 length:缓冲区buf的长度
 size:取size函数,传入obj对象,返回这个对象占用了多少个字节,obj list里存放的对象,max_size:这个对象理应占的最大字节数,i,第i个对象
 如果size函数返回了一个比max_size更大的数,那么以size返回的数据的最大值作为max_size被写入
 returnVal:往缓冲区实际写入的字节数
 */
 unsigned int (*packVarLength)(struct myListOP *self,char* buf,unsigned int length,unsigned short (*size)(void* obj,unsigned short int max_size,unsigned int i),unsigned short int max_size);
 /*
 将字节流解包成对象,会写入尾部的重复字节
 字节流格式：unsigened short int used（2字节)unsigened short int datalen(2字节) data
 如果.pack_use_max_size != 0,使用used之后的2字节作为最大长度进行创建内存
 buf:缓冲区,字节流读取的地址
 printData:返回操作类初始化时需要的printData
 returnVal:操作类
 */
 struct myListOP* (*unpack)(struct myListOP* self,char* buf,void(*printData)(void*));
 unsigned int length;//链表的长度
 unsigned int __index;//内部变量,加速slice与_slice的返回
 unsigned int __lastPacked;//内部变量,记录上次打包的位置
 char pack_use_max_size;//是否使用最大的元素大小,修改打包的格式
 char packed;//是否打包完毕
 myListP __last;//内部变量,加速slice与_slice的返回
 myListP __head;//内部变量,加速slice与_slice的返回

} myListOP;
//初始化函数
myListOP* myListDInit(void(*printData)(void*));
/*
将字节流解包成对象,会写入尾部的重复字节
字节流格式：unsigened short int used（2字节)unsigened short int datalen(2字节) data
如果pack_use_max_size != 0,使用used之后的2字节作为最大长度进行创建内存
buf:缓冲区,字节流读取的地址
printData:返回操作类初始化时需要的printData
returnVal:操作类
*/
myListOP* myListDUnpack(char pack_use_max_size,char* buf,void(*printData)(void*));
#endif

array.c

 // 实现list的头插,尾插,头删,尾删,任意位置删除,任意位置添加
#include 
#include 
#include "array.h"
static int isNull(myArrayOP* self){
 if (self ==0 || self->data ==0){return 1;}
 return 0;
}
static int isNullOrEmpty(myArrayOP* self){
 if (isNull(self) || self->length ==0)
 {
     return 1;
 }
 return 0;
 
}
static void* slice(myArrayOP* self,unsigned int i){
 if (i>= self->length || i<0)
 {
     return 0;
 }
 
 return self->data+self->size*i;
}
static int del(myArrayOP* self,unsigned int where){
 if (isNullOrEmpty(self))
 {
     return 0;
 }//判断是否非空
 void* data = self->data;
 if (where > self->length || where <0)
 {
     return 0;
 }
 if (self->length == where+1)//如果最后一个,则直接移动length,避免越界
 {
     self->length = self->length-1;
     return 0;
 }
 
 for (unsigned int i = where; i < self->length; i++)
 {
     // data->data[i] = data->data[i+1];
     memcpy(data+self->size*i,data+self->size*(i+1),self->size);
 }
 self->length = self->length-1;
 return 0;
 
}
static void* delNoFree (myArrayOP* self,unsigned int where){
 if (isNullOrEmpty(self))
 {
     return 0;
 }//判断是否非空
 void* ret = malloc(self->size);
 memcpy(ret,self->slice(self,where),self->size);
 del(self,where);
 return ret;
}
static int insert(myArrayOP* self,unsigned int where,void* obj){
 if (isNull(self))
 {
     return 0;
 }//判断是否非空
 void* data = self->data;
 if (self->length == self->max_length)
 {
     return 0;
 }
 if (where > self->length||where<0)
 {
     return 0;
 }
 
 if (self->length ==0)
 {
     // data->data[0] = obj;
     memcpy(data,obj,self->size);
     self->length++;
     return 1;
 } 
 
 for (unsigned int i =self->length ; i > where; i--)
 {
     memcpy(data+self->size*i,data+self->size*(i-1),self->size);
 }
 self->length = self->length+1;
 memcpy(data+where*self->size,obj,self->size);
 
 return 1;
}

static int insertHead(myArrayOP* self,void* num){
 return insert(self,0,num);
}
static int insertTail(myArrayOP* self,void* num){
 if (isNull(self))
 {
     return 0;
 }//判断是否非空
 return insert(self,self->length,num);

}
static int delHead (myArrayOP* self){
 return del(self,0);
}
static int delTail (myArrayOP* self){
 return del(self,self->length);
}
static void* delHeadNoFree (myArrayOP* self){
 return delNoFree(self,0);
}
static void* delTailNoFree (myArrayOP* self){
 return delNoFree(self,self->length-1);
}
static unsigned int find(struct myArrayOP*self,void* obj,unsigned int times){
 void* p =0;
 unsigned int count =0;
 for (unsigned int i = 0; i < -1; i++)
 {
     p=slice(self,i);
     if (p==0)
     {
         break;
     }
     if (p==obj)
     {
         if (times == count)
         {
             return i;
         }
         count ++;
     }

 }
 return -1;
}
static unsigned int findby(struct myArrayOP*self,int(*cmp)(void*,void*),void*(*filed)(void*),void*target,unsigned int times){//cmp应该返回是否是要找的值
 void* p =0;
 unsigned int count =0;
 for (unsigned int i = 0; i < -1; i++)
 {
     p=self->slice(self,i);
     if (p==0)
     {
         break;
     }
     if (cmp(filed(p),target)==0)
     {
         if (times == count)
         {
             return i;
         }
         count ++;
     }
 }
 return -1;
}
static unsigned int _index(myArrayOP* self,void* obj){
 return find(self, obj,0);
}

static unsigned int unic (struct myArrayOP*self,void*(*field)(void*),unsigned int times){
 unsigned int count=0;
 unsigned int ret =0;
 for (unsigned int i = 1; i < self->length; i++)
 {
     count =0;
     for (unsigned int j = i+1; j < self->length; j++)
     {
         if (memcmp(field(self->slice(self,i)),field(self->slice(self,j)),self->size)==0)
         {
             if (count >= times)
             {
                 self->del(self,j);
                 j=j-1;
             }
             count=count+1;
             ret = ret+1;
         }
     }
 }
 return ret;
}
static void print(myArrayOP * self){
 void* obj;
 unsigned int i=0;
 if (isNullOrEmpty(self))
 {
     return;
 }
 while (obj=self->slice(self,i++))
 {
     self->__str(obj);
 }
 printf("
");
 return;
}
static void destory(myArrayOP *self){
 if (self ==0)
 {
     return;
 }
 if (self->data ==0)
 {
     return;
 }
 free (self->data);
 self->data=0;
 free(self);
}

static void _quickSort(myArrayOP *self,long int start,long int end,int(*cmp)(void*, void*),void*(*filed)(void*),int reverse){
 if (start < end) {
     void* base = malloc(self->size);
     memcpy(base,slice(self, start),self->size);// 以要进行排序数组第0个元素为base
     int left = start;  // 左指针
     int right = end;   // 右指针

     while (left < right) {
         // 从右向左找，找到比base小的元素
         while (left < right && (cmp(filed(slice(self, right)), filed(base)) * reverse) >= 0) {
             right--;
         }
         memcpy(slice(self, left),slice(self, right),self->size);
         while (left < right && (cmp(filed(slice(self, left)), filed(base)) * reverse) <= 0) {
             left++;
         }
         memcpy(slice(self, right),slice(self, left),self->size);
     }
     // slice(self, left)->data = base; // 将base放到正确的位置
     memcpy(slice(self, left),base,self->size);
     free(base);
     // 递归排序左右子数组
     _quickSort(self, start, left - 1, cmp,filed, reverse);
     _quickSort(self, left + 1, end, cmp,filed, reverse);
 }
}
static void quickSort(myArrayOP *self,int(*cmp)(void*, void*),void*(*filed)(void*),int reverse){
 if (isNullOrEmpty(self))
 {
     return;
 }
 return _quickSort(self,0,self->length-1,cmp,filed,reverse);
}
static unsigned short int mysizeof(char * obj,unsigned int size){
 if (obj==0||size==0){return 0;}
 for (; size>1&&*(char*)(obj+size-1) - *(char*)(obj+size-2)==0; size--);//尾地址为obj+size-1
 return size;
}
static unsigned int pack(myArrayOP *self,char* buf,unsigned int length){
 //将对象打包成字节流
 //格式：unsigened short int used（2字节)unsigened short int len(2字节)data
 //如果定义了宏 __PACK_WRITE_MAXSIZE__,则在used后写入max_size 
 unsigned int used=0;
 void* obj=0;
 unsigned short int size=0;
 unsigned int min_buf_len = sizeof(unsigned short int)*2;
 self->packed=0;
 if (self->pack_use_max_size)
 {
     min_buf_len =  sizeof(unsigned short int)*3;
 }
 if (length<min_buf_len)
 {
     return 0;
 }
 if (isNullOrEmpty(self))
 {
     return 0;
 }
 // 为总大小腾出空间
 used+=sizeof(unsigned short int);

 
 if (self->pack_use_max_size)
 {
     *(unsigned short int *)(buf+used) =self->size;
     used+=sizeof(unsigned short int);
 }
 //再循环写入每个元素
 while(obj=self->slice(self,self->__lastPacked++)){
     size = mysizeof(obj,self->size);
     //需要写入的字节数为size+sizeof（unsigned short int）
     //如果写入量超过长度，则返回实际使用量；
     if (used+size+sizeof(unsigned short int)>length)
     {
             *(unsigned short int *)(buf) =used;
             self->__lastPacked--;//回退计数器
             return used;//未打包完,返回使用量
     }
     //否则则写入大小和数据
     *(unsigned short int *)(buf+used) =size;
     used+=sizeof(unsigned short int);
     memcpy(buf+used,obj,size);
     used+=size;
 }
 self->__lastPacked = 0;//这里说明打包完了
 self->packed=1;
 *(unsigned short int *)(buf) =used;
 return used;
}
myArrayOP* myArrayUnpack(char pack_use_max_size,char* buf,void(*printData)(void*)){
 unsigned int total = *(unsigned short int *)buf;//协议包的总大小
 if (total<2*sizeof(unsigned short int)+1)//如果比最小的情况还小(一个总大小,一个对象,对象只写入了一个字节)
 {
     return 0;
 }
 
 //先循环遍历,找到最大的元素大小和要申请的地址的大小
 unsigned int delta=sizeof(unsigned short int);//偏移量,头两个字节是协议包大小
 unsigned int num =0;//总元素数量
 unsigned int maxSize = *(unsigned short int *)(buf+delta);//最大元素的大小,假设第一个最大
 unsigned int currentSize=0;
 if (pack_use_max_size)
 {
     // 如果有写max_size 则使用
     maxSize = *(unsigned short int *)(buf+sizeof(unsigned short int));
     delta+=sizeof(unsigned short int);
 }
 
     while (delta<total)//不会出现等于,最少会写入1字节的obj
 {
     num=num+1;
     currentSize = *(unsigned short int *)(buf+delta);
     if (maxSize<currentSize)
     {
         maxSize = currentSize;
     }
     delta+=currentSize+sizeof(unsigned short int);
 }
 
 delta = sizeof(unsigned short int);
 //再申请内存
 myArrayOP* arr = myArrayInit(maxSize*num,maxSize,printData);if (arr == 0){return 0;}
 //为了方便还原数据,申请maxSize大小的内存;
 void* obj=malloc(maxSize);if (obj == 0){return 0;}

 while (delta<total)//不会出现等于,最少会写入1字节的obj
 {
     currentSize = *(unsigned short int *)(buf+delta);
     delta+=sizeof(unsigned short int);
     memset(obj,*(char*)(buf+delta+currentSize-1),maxSize);//以最后一个字节初始化
     memcpy(obj,buf+delta,currentSize);
     delta+=currentSize;
     arr->append(arr,obj);
 }
 free(obj);
 arr->pack_use_max_size=pack_use_max_size;//继承原有的格式
 return arr; 
}
static myArrayOP* unpack(myArrayOP* self,char* buf,void(*printData)(void*)){
 //兼容层
 return myArrayUnpack(self->pack_use_max_size,buf,printData);
}
static int delByAddr(myArrayOP *self,void* obj){
 if (self==0)
 {
     return -1;
 }
 if (isNullOrEmpty(self))
 {
     return -1;
 }
 if (obj<self->data||obj>(self->data+self->length*self->size))
 {
     return -1;
 }
 unsigned int where = (unsigned int)((char*)obj - (char*)self->data)/self->size;
 self->del(self,where);
 return where;
}
static int add(myArrayOP *self,myArrayOP *other){
 void* obj =0;
 unsigned int i =0;
 while (obj=other->slice(other,i++))
 {
     self->append(self,obj);
 }
}
static int sub(myArrayOP *self,myArrayOP *other){
 int ret =0;
 if (self ==0||other ==0) 
 {
     return ret;
 }
 if (self->isNullOrEmpty(self)||other->isNullOrEmpty(other))
 {
     return ret;
 }
 if (self->size!=other->size) //两个数组中数据大小不一样,不比较
 {
     ret = -1;
     return ret;
 }
 unsigned int size = self->size;
 
 
 void* obj_self =0;
 void* obj_other=0;
 unsigned int i =0;
 unsigned int j=0;
 
 while (obj_other=other->slice(other,i++))
 {
     while (obj_self=self->slice(self,j++))
     {
         if (memcmp(obj_self,obj_other,size)==0)
         {
             self->delByAddr(self,obj_self);
         }
     }
 }
}

static myArrayOP* copy(myArrayOP* self){
 myArrayOP* ret = myArrayInit(self->max_length,self->size,self->__str);
 memcpy(ret->data,self->data,self->size*self->length);
 return  ret;
}
static myArrayOP* setter(myArrayOP* self,myArrayOP*other){
 memcpy(self->data,other->data,self->size*self->length);
 return  self;
}
myArrayOP* myArrayInit(unsigned int max_length,unsigned int size,void(*printData)(void*)){
 myArrayOP * self = 0;
 self = (myArrayOP*) malloc(sizeof(myArrayOP));
 bzero(self,sizeof(myArrayOP));

 self->data = calloc(max_length,size);
 // malloc(sizeof(myList));
 bzero(self->data,sizeof(max_length*size));
 self->max_length=max_length;
 self->size=size;
 self->__str=printData;
 self->del = del;
 self->delHead=delHead;
 self->delTail=delTail;
 self->delNoFree=delNoFree;
 self->find=find;
 self->index=_index;
 self->insert=insert;
 self->inserTail=insertTail;
 self->insertHead=insertHead;
 self->isNullOrEmpty=isNullOrEmpty; 
 self->slice=slice;
 self->unic=unic;
 self->print=print;
 self->destory=destory;
 self->delHeadNoFree=delHeadNoFree;
 self->delTailNoFree=delTailNoFree;
 self->delNoFree=delNoFree;
 self->quickSort=quickSort;
 self->_quickSort=_quickSort;
 self->append=insertTail;
 self->push=insertTail;
 self->queue=insertTail;
 self->dequeue=delHeadNoFree;
 self->pop=delTailNoFree;
 self->findby=findby;
 self->pack=pack;
 self->unpack=unpack;
 self->copy=copy;
 self->setter = setter;
 return self;
}

array.h

 #ifndef  __MYARRAYLIST_STRUCT__
#define __MYARRAYLIST_STRUCT__
#include 
// 数组,堆上的对象数组
// 用法: 需要外部创建结构体或对象,同时准备好该结构体或对象的打印(print)方法
// 请注意:长度从0开始,到length结束
// 推荐以以下方式迭代链表
// while(obj=.slice(,i++))
// 以下划线(_)开头的方法为某一方法的补充,或是低级实现,理想情况下不应当被使用
// 以下划线(__)开头的字段为内部实现依赖的字段,不应当被外界改变
// 在数组的实现中,部分方法依赖于长度(.length),其长度不应当被改变
// 以下操作是合法的
// _slice(0),_slice(length),_slice(-1),_slice(length+1)返回值分别为头数据,尾数据,0,0
// slice(1),slice(length),返回值分别为头尾节点内存的对象.
// 同一个链表操作类操作不同的链表 即op1->fun(op2,agrs) 该结果应该与 op2->fun(op2,agrs) 一致,但无法保证跨链表操作类结果一致

/* 封装测试于2025/4/30,修复部分.length操作
*  
* 2025/4/16 添加类
* 2025/4/16 添加通用的测试方法
* 2025/4/25 添加_destory方法,未测试,理应是好的
* 2025/4/27 修复findby与quickSort,_quickSort,findby的cmp函数,使其统一,并新增字段field函数,应当返回一对象内部的地址
* 2025/4/27 针对有头单项链表测试,修改有头单项链表,定义1-.length为合法操作
* 2025/5/9  修补数组,使其对任意的obj有效,重命名新增NoFree函数
* 2025/5/10 新增pack和unpack方法,打包/解包成数据流
*/
typedef struct myArrayOP{
 void* data;  //堆上的数组
 size_t length; //目前的长度,0为空
 size_t max_length;//数组的最大长度
 unsigned int __lastPacked;
 char pack_use_max_size;//是否使用最大的元素大小
 char packed;
 void (*__str)(void*);//打印方法
 unsigned short int size;//内部每个元素的大小
 int (*isNullOrEmpty)(struct myArrayOP*);//判断列表是否为空
 int (*insertHead)(struct myArrayOP*,void* obj);//在数组的头插入
 int (*inserTail)(struct myArrayOP*,void* obj);//在数组的末尾插入
 int (*delHead)(struct myArrayOP*);//删除数组的头
 int (*delTail)(struct myArrayOP*);//删除数组的尾
 void* (*delHeadNoFree)(struct myArrayOP*);//删除数组的头(不会自动调用free),会copy一份返回
 void* (*delTailNoFree)(struct myArrayOP*);//删除数组的尾(不会自动调用free),会copy一份返回
 int (*del)(struct myArrayOP*,unsigned int where);//在数组的where处删除某个对象(会自动调用free)
 void* (*delNoFree)(struct myArrayOP*,unsigned int where);//在数组的where处删除某个对象(不会自动调用free),会copy一份返回
 int (*insert)(struct myArrayOP*,unsigned int where,void* obj);//在数组的where处插入对象
 unsigned int (*index)(struct myArrayOP*,void* obj);//取该对象的数组下标
 unsigned int (*find)(struct myArrayOP*,void* obj,unsigned int times);//查找该对象times+1次,返回times+1次所对应的下标,times为0表示取第一个
 unsigned int (*findby)(struct myArrayOP*self,int(*cmp)(void*,void*),void*(*filed)(void*),void*target,unsigned int times);//使用cmp查找该对象的filed字段对应的target，times+1次,返回times+1次所对应的下标,times为0表示取第一个
 unsigned int (*unic) (struct myArrayOP*self,void*(*field)(void*),unsigned int times);//在数组上保证数组上某个对象最多不出现time+1次,filed函数应当返回特征字段的地址,size应当设置为特征的大小
 void* (*slice)(struct myArrayOP* self,unsigned int i);//切片函数,数组上的第i个对象
 void (*destory)(struct myArrayOP *self);//销毁数组,会释放所有的该数组上的对象
 // void (*destoryNoFree)(struct myArrayOP *self);
 void (*print)(struct myArrayOP * self);//使用.__str方法打印数组上的所有对象
 void (*_quickSort)(struct myArrayOP *self,long int start,long int end,int(*cmp)(void*, void*),void*(*filed)(void*),int reverse);//从start到end的快速排序
 void (*quickSort)(struct myArrayOP *self,int(*cmp)(void*, void*),void*(*filed)(void*),int reverse);//整个链表的快速排序,cmp方法返回给出的两个对象哪个更大,reverse为正则正序,为负则逆序,0不做排序
 int (*append)(struct myArrayOP*,void* data);//尾插
 void*  (*dequeue)(struct myArrayOP* self);//在数组上将第0个元素删除,将元素拷贝一份到新的堆空间并返回拷贝后的地址,需要手动free
 void*  (*pop)(struct myArrayOP* self);//在数组上将最后一个元素删除,将元素拷贝一份到新的堆空间并返回拷贝后的地址,需要手动free
 int  (*push)(struct myArrayOP*,void* data);//拷贝该元素到数组的最后一位
 int  (*queue)(struct myArrayOP*,void* data);//拷贝该元素到数组的最后一位
 unsigned int (*pack)(struct myArrayOP *self,char* buf,unsigned int length);//将其内部的数据打包成字节流
 struct myArrayOP* (*unpack)(struct myArrayOP *self,char* buf,void(*printData)(void*));//将字节流解包成内部数据,返回一个新的对象
 int (*delByAddr)(struct myArrayOP *self,void* obj);//按地址删除某一元素
 struct myArrayOP *(*copy)(struct myArrayOP *self);//拷贝副本
 struct myArrayOP *(*setter)(struct myArrayOP *self,struct myArrayOP *other);//将other的数据域拷贝至self的数据域
} myArrayOP;
//初始化函数
myArrayOP* myArrayInit(unsigned int max_length,unsigned int size,void(*print)(void*));
/*
将字节流解包成对象,会写入尾部的重复字节
字节流格式：unsigened short int used（2字节)unsigened short int datalen(2字节) data
如果pack_use_max_size != 0,使用used之后的2字节作为最大长度进行创建内存
buf:缓冲区,字节流读取的地址
printData:返回操作类初始化时需要的printData
returnVal:操作类
*/
myArrayOP* myArrayUnpack(char pack_use_max_size,char* buf,void(*printData)(void*));
#endif