简单的基于sqlite的服务器和客户端实现

server.c

1. #include <stdio.h>
2. #include <string.h>
3. #include <unistd.h>
4. #include <stdlib.h>
5. #include <sys/types.h>
6. #include <sys/stat.h>
7. #include <fcntl.h>
8. #include <pthread.h>
9. #include <semaphore.h>
10. #include <wait.h>
11. #include <signal.h>
12. #include <sys/socket.h>
13. #include <arpa/inet.h>
14. #include <sys/ipc.h>
15. #include <sys/sem.h>
16. #include <semaphore.h>
17. #include <sys/msg.h>
18. #include <sys/shm.h>
19. #include <sys/un.h>
20. #include <sys/time.h>
21. #include <sys/select.h>
22. #include <sys/epoll.h>
23. #include "doublyList.h
24. "
25. #include <sqlite3.h>
26. #include "array.h
27. "
28. myListOP * fdList;
31. int isSameAddr(void* a,void*b){
32.     return a-b;
33. }
34. int isSameInt(int* a,int*b){
35.     return *a-*b;
36. }
40. struct info{
41.     struct sockaddr_in client_addr;
42.     int fd;
43.     struct epoll_event* event;
44.     myListOP* record;
45. };
47. int* getfd(struct info* info){
48.     return &(info->event->data.fd);
49. }
54. struct patientRecord
55. {
56.     time_t time;
57.     char patientName[40];
58.     char patientRec[128];
59.     char doctorDia[128];
60.     char tablet[128];
61.     char doctorAdv[128];
62.     //size=4*128+4+40=556
63. };
64. struct patientRecord * createPatinetRecord(time_t time,char* patientName,\
65.                         char* patientRec,char* doctorDia,char* tablet,char* doctorAdv){
66.                            struct patientRecord * ret = malloc (sizeof (struct patientRecord));
67.                            ret->time = time;
68.                            if (patientName)
69.                            {
70.                             strcpy(ret->patientName,patientName);
71.                            }
72.                            strcpy(ret->patientRec,patientRec);
73.                            strcpy(ret->doctorDia,doctorDia);
74.                            strcpy(ret->tablet,tablet);
75.                            strcpy(ret->doctorAdv,doctorAdv);
76.                            return ret;
77.                         }
78. enum enum_send_t{
79.     send_record =1,
80.     read_record,
81. };
82. struct send_t
83. {
84.     enum enum_send_t type;
85.     struct patientRecord patientRecord;
86. };
87. static void printRec(struct patientRecord* rec){
88.     char timeStr[64]; // 用于存储格式化后的时间字符串
89.     strftime(timeStr, sizeof(timeStr), "%Y-%m-%d %H:%M:%S", localtime(&rec->time));
90.     printf("%s::\n 病人描述:%s\n, 医生诊断:%s\n, 开药:%s\n, 医嘱:%s\n",
91.            timeStr, rec->patientRec, rec->doctorDia, rec->tablet, rec->doctorAdv);
92. }
93. static void printSend_t(struct send_t* send){
94.     if (send->type == send_record)
95.     {
96.         printf("send_record\n");
97.     }
98.         if (send->type == read_record)
99.     {
100.         printf("read_record\n");
101.     }
103.     printRec(&send->patientRecord);
104. }
106. struct info* creatInfo(struct sockaddr_in *client_addr,int fd,struct epoll_event* event){
107.     struct info* ret = malloc(sizeof(struct info));
108.     ret->record = myListDInit(printSend_t);
109.     if (client_addr)
110.     {
111.         ret->client_addr=*client_addr;
112.     }
113.     else{
114.         memset(&ret->client_addr,0,sizeof(struct sockaddr_in));
115.     }
116.     ret->event = event;
117.     ret->fd = fd;
118.     return ret;
119. }
120. void printInfo(struct info* info){
121.     static char ip_human[16] = {0};
122.     if (info ==0 || (&(info->client_addr)==0))
123.     {
124.         return;
125.     }
126.    
127.     int port_human=ntohs(info->client_addr.sin_port);
128.     inet_ntop(AF_INET,&info->client_addr.sin_addr,ip_human,16);
129.     printf("ip:%s,port:%d,fd:%d::",ip_human,port_human,info->fd);
130. }
132. sqlite3* db;
134. int mysqlite3_append(struct patientRecord* rec){
135.     char sql[1024]="";
136.     sprintf(sql,"create table if not exists %s (\
137.         日期 INTEGER ,\
138.         病人口述 TEXT,\
139.         医生诊断 TEXT,\
140.         医生开药 TEXT,\
141.         医嘱 text \
142.         );", rec->patientName);
143.     char ** result;
144.     char * errmsg;
145.     int ret = 0;
146.     ret=sqlite3_exec(db,sql,0,0,&errmsg);
147.     if (ret)
148.     {
149.         //sql执行一场
150.         printf("在添加表格时出现异常:: %s\n",errmsg);
151.         return EXIT_FAILURE;
152.     }
153.     sprintf(sql,"insert into %s (日期,病人口述,医生诊断,医生开药,医嘱)\
154.         values (%ld,'%s','%s','%s','%s');",\
155.         rec->patientName,rec->time,rec->patientRec,rec->doctorDia,rec->tablet,rec->doctorAdv);
156.     ret=sqlite3_exec(db,sql,0,0,&errmsg);
157.     if (ret)
158.     {
159.         //sql执行一场
160.         printf("在添加数据时出现异常:: %s\n",errmsg);
161.         return EXIT_FAILURE;
162.     }
163.     return 0;
164. }
165. int callback (myListOP* list,int argc, char ** argv,char** col){
166.     // for (int i = 0; i < argc; i++)
167.     // {
168.     //     /* code */
169.     // }
171.     list->append(list,createPatinetRecord(atol(argv[0]),0,argv[1],\
172.                 argv[2],argv[3],argv[4]));
173.     return 0;
174.    
175. }
176. int mysqlite3_read(struct patientRecord * rec,myListOP* list){
177.     char sql[1024]="";
178.    
179.     sprintf(sql,"create table if not exists %s (\
180.         日期 INTEGER ,\
181.         病人口述 TEXT,\
182.         医生诊断 TEXT,\
183.         医生开药 TEXT,\
184.         医嘱 text \
185.         );", rec->patientName);
186.     char ** result;
187.     char * errmsg;
188.     int ret = 0;
189.     ret=sqlite3_exec(db,sql,0,0,&errmsg);
190.     if (ret)
191.     {
192.         //sql执行一场
193.         printf("在添加表格时出现异常:: %s\n",errmsg);
194.         return EXIT_FAILURE;
195.     }
196.     sprintf(sql,"select * from %s ;", rec->patientName);
197.     ret=sqlite3_exec(db,sql,callback,list,&errmsg);
198.     if (ret)
199.     {
200.         //sql执行一场
201.         printf("在添加数据时出现异常:: %s\n",errmsg);
202.         return EXIT_FAILURE;
203.     }
204.     return 0;
205. }
206. int serverfun(struct info* info){
207.     int client = info->fd;
208.     char ip_human[16]={0};
209.     int port_human=0;
210.     struct sockaddr_in client_addr = {0};
211.     client_addr = info->client_addr;
212.     inet_ntop(AF_INET,&client_addr.sin_addr,ip_human,16);
213.     port_human=ntohs(client_addr.sin_port);
214.     char buf[560] = "";
215.     int res = read(client,buf,sizeof(unsigned short int));
216.     int size = *(unsigned short int*)buf;
217.     if (res == 0)
218.     {
219.         printf("客户端已断开连接:\nIP:%s\nport:%d\n",ip_human,port_human);
220.         close(client);
221.         fdList->del(fdList,fdList->find(fdList,info,0));
222.         return 0;
223.     }
224.     res = read(client,buf+sizeof(unsigned short int),size-sizeof(unsigned short int));
225.     myListOP * tmp =0;
226.     tmp = info->record->unpack(info->record,buf,printRec);
227.     info->record->destory(info->record);
228.     info->record=tmp;
229.     struct send_t * st = 0;
230.     unsigned int i=0;
231.     while (st = info->record->slice(info->record,i++))
232.     {
233.         if (st->type == send_record)
234.         {
235.             mysqlite3_append(&st->patientRecord);
236.         }
237.         if (st->type == read_record)
238.         {
239.             myListOP* list = myListDInit(printRec);
240.             mysqlite3_read(&st->patientRecord,list);
241.             while (list->packed == 0)
242.             {
243.                 res = list->pack(list,buf,560,sizeof(struct patientRecord));
244.                 send(info->fd,buf,res ,0);
245.             }
246.             list->destory(list);
247.         }
248.         
249.     }
250.     return 1;
251. }
252. void printEvent(struct epoll_event event){
253.     printf("fd:%d,ptr:%p-->",event.data.fd,event.data.ptr);
254. }
256. int main(int argc, char const *argv[])
257. {
258.     if (argc<2)
259.     {
260.         printf("请输入端口号\n");
261.         return 1;
262.     }
263.    
264.     int server = socket(AF_INET,SOCK_STREAM,0);
265.     sqlite3_open("/home/mr-oy/c-codes/数据库/hospital.db",&db);
266.     struct sockaddr_in addr={0};
267.     addr.sin_family=AF_INET;
268.     addr.sin_port=htons(atoi(argv[1]));
269.     addr.sin_addr.s_addr=inet_addr("0.0.0.0");
271.     if(bind(server,(struct sockaddr * )&addr,sizeof(addr))==-1){
272.         perror("bind:");
273.         return 1;
274.     }
275.     struct sockaddr_in client_addr = {0};
276.     int client_len = sizeof(client_addr);
278.     int ret;
279.     int max = 10;
280.     listen(server,max);
281.     char ip_human[16]="";
282.     int port_human = 0;
283.     //创建监视列表
284.     int epoll_handler = epoll_create1(EPOLL_CLOEXEC);
285.     // 将服务器加入到handeler内
286.     struct epoll_event serverEvent;
287.     serverEvent.events=EPOLLIN|EPOLLET;
288.     serverEvent.data.fd=server;
289.     epoll_ctl(epoll_handler,EPOLL_CTL_ADD,server,&serverEvent);
291.     int client;
292.     fdList = myListDInit((void(*)(void*))printInfo);
293.     struct info * currentinfo=0;
294.     struct epoll_event* currentevent=0;
295.     int* currentfd =0;
296.     unsigned int i=0;
298.     // fdList->append(fdList,creatInfo(0,server,&serverEvent));
299.     myArrayOP* eventList = myArrayInit(20,sizeof(struct epoll_event),printEvent);
301.     printf("服务器正在运行:\n");
302.     for (;;)
303.     {
304.         i=0;
305.         memset(eventList->data,0,eventList->max_length*eventList->size);
306.         eventList->length = epoll_wait(epoll_handler,eventList->data,eventList->max_length,-1);
307.         while (currentevent = (struct epoll_event*)eventList->slice(eventList,i++))
308.         {
309.             currentfd = &(currentevent->data.fd);
310.             if (*currentfd == server)//有新的客户端连接
311.             {
312.                 client = accept(server,(struct sockaddr * )&client_addr,&client_len);
313.                 struct epoll_event* clientevent = malloc(sizeof(struct epoll_event)) ;
314.                 memset(clientevent,0,sizeof(struct epoll_event));
315.                 clientevent->data.fd=client;
316.                 clientevent->events=EPOLLIN|EPOLLET;
317.                 fdList->append(fdList,creatInfo(&client_addr,client,clientevent));
318.                 epoll_ctl(epoll_handler,EPOLL_CTL_ADD,client,clientevent);
319.                 inet_ntop(AF_INET,&client_addr.sin_addr,ip_human,16);
320.                 port_human=ntohs(client_addr.sin_port);
321.                 printf("客户端已连接:\nIP:%s\nport:%d\n",ip_human,port_human);
322.                 //将该fd添加到epoll
323.                 continue;;
324.             }
325.             //客户端操作
326.             else if (*currentfd != server)
327.             {
328.                 unsigned int index= fdList->findby(fdList,isSameInt,getfd,currentfd,0);
329.                 // fdList->print(fdList);
330.                 currentinfo = fdList->slice(fdList,index);
331.                 serverfun(currentinfo);
332.             }
333.             
334.         }
335.         
336.         
337.         
339.     }  
340.     return 0;
341. }

复制代码

client.c

1. #include <stdio.h>
2. #include <string.h>
3. #include <unistd.h>
4. #include <stdlib.h>
5. #include <sys/types.h>
6. #include <sys/stat.h>
7. #include <fcntl.h>
8. #include <pthread.h>
9. #include <semaphore.h>
10. #include <wait.h>
11. #include <signal.h>
12. #include <sys/socket.h>
13. #include <arpa/inet.h>
14. #include <sys/ipc.h>
15. #include <sys/sem.h>
16. #include <semaphore.h>
17. #include <sys/msg.h>
18. #include <sys/shm.h>
19. #include <sys/un.h>
20. #include "doublyList.h
21. "
22. #include "array.h
23. "
24. struct patientRecord
25. {
26.     time_t time;
27.     char patientName[40];
28.     char patientRec[128];
29.     char doctorDia[128];
30.     char tablet[128];
31.     char doctorAdv[128];
32.     //size=4*128+4+40=556
33. };
34. enum enum_send_t{
35.     send_record =1,
36.     read_record,
37. };
38. struct send_t
39. {
40.     enum enum_send_t type;
41.     struct patientRecord patientRecord;
42. };
44. struct send_t * createSend_t(enum enum_send_t type,time_t time,char* patientName,\
45.                         char* patientRec,char* doctorDia,char* tablet,char* doctorAdv){
46.                            struct send_t * st = malloc (sizeof (struct send_t));
47.                            st->type = type;
48.                            struct patientRecord *ret = &st->patientRecord;
49.                            memset(ret,0,sizeof(struct patientRecord));
50.                            ret->time = time;
51.                            strcpy(ret->patientName,patientName);
52.                            if (patientRec !=0)
53.                            {
55.                             strcpy(ret->patientRec,patientRec);
56.                             strcpy(ret->doctorDia,doctorDia);
57.                             strcpy(ret->tablet,tablet);
58.                             strcpy(ret->doctorAdv,doctorAdv);
59.                            }
60.                            
61.                            return st;
62.                         }
64. static void printRec(struct patientRecord* rec){
65.     char timeStr[64]; // 用于存储格式化后的时间字符串
66.     strftime(timeStr, sizeof(timeStr), "%Y-%m-%d %H:%M:%S", localtime(&rec->time));
67.     printf("%s::\n 病人描述:%s\n, 医生诊断:%s\n, 开药:%s\n, 医嘱:%s\n",
68.            timeStr, rec->patientRec, rec->doctorDia, rec->tablet, rec->doctorAdv);
69. }
70. static void printSend_t(struct send_t* send){
71.     if (send->type == send_record)
72.     {
73.         printf("send_record\n");
74.     }
75.         if (send->type == read_record)
76.     {
77.         printf("read_record\n");
78.     }
80.     printRec(&send->patientRecord);
81. }
82. int main(int argc, char const *argv[])
83. {
84.     if (argc<3)
85.     {
86.         printf("请输入端口号\n");
87.         printf("请输入模式\n");
88.         return 1;
89.     }
90.     char patientName[40];
91.     char patientRec[128];
92.     char doctorDia[128];
93.     char tablet[128];
94.     char doctorAdv[128];
96.    
97.     myListOP* list = myListDInit(printSend_t);
99.     int clinet = socket(AF_INET,SOCK_STREAM,0);
100.     struct sockaddr_in addr={0};
101.     addr.sin_family=AF_INET;
102.     addr.sin_port=htons(atoi(argv[1]));
103.     addr.sin_addr.s_addr=inet_addr("127.0.0.1");
105.     char buf[560] = {0};
106.     int used =0;
108.     if(connect(clinet,(struct sockaddr*)&addr,sizeof(addr))==-1){
109.         perror("connect:");
110.         return 1;
111.     }
112.     if (strcmp(argv[2],"-u"))
113.     {
114.     for (;;)
115.     {
116.         
117.         printf("请输入病人姓名\n");
118.         scanf(" %s",patientName);
119.         printf("请输入病人自述\n");
120.         scanf(" %s",patientRec);
121.         printf("请输入医生诊断\n");
122.         scanf(" %s",doctorDia);
123.         printf("请输入药物\n");
124.         scanf(" %s",tablet);
125.         printf("请输入医嘱\n");
126.         scanf(" %s",doctorAdv);
128.         list->append(list,createSend_t(send_record,time(NULL),\
129.         patientName,patientRec,doctorDia,tablet,doctorAdv
130.         ));
131.         used = list->pack(list,buf,560,560);
132.         write(clinet,buf,used);
133.     }  
134.     }
135.     else{
136.     for (;;)
137.     {
138.         
139.         printf("请输入病人姓名\n");
140.         scanf(" %s",patientName);
141.         list->append(list,createSend_t(read_record,0,\
142.         patientName,0,0,0,0
143.         ));
144.         used = list->pack(list,buf,560,560);
145.         write(clinet,buf,used);
146.         while (1)
147.         {
148.             used = read(clinet,buf,sizeof(unsigned short int));//理论上会卡死在这行,回头优化
149.             int size = *(unsigned short int*)buf;
150.             used = read(clinet,buf+sizeof(unsigned short int),size-sizeof(unsigned short int));
151.             myListOP * tmp =0;
152.             tmp = myListDUnpack(0,buf,printRec);
153.             tmp->print(tmp);
154.         }
155.         
156.         
157.         
158.         
159.     }  
160.     }
161.    
162.    
163.     return 0;
164. }

复制代码

依赖:
doublyLIst.c

1. #include "doublyList.h
2. "
3. #include <stdlib.h>
4. #include <stdio.h>
5. #include <string.h>
6. static int isNull(myListOP * self){
7.     return self==0 || self->data==0;//头的位置是空,则为null
8. }
9. static int isEmpty(myListOP * self){
10.     return self->data->next==0||self->data->data==0;//头的data的指针指向自己则为null
11. }
12. static int isNullOrEmpty(myListOP * self){
13.     return isNull(self)||isEmpty(self);
14. }
15. static void* dequeue(myListOP * self){
16.     void * ret=0;
17.     if (isNullOrEmpty(self))
18.     {
19.         return 0;
20.     }
21.     if (self->data->next == self->data) //只有一个的情况下
22.     {
23.         self->length--;
24.         ret = self->data->data;
25.         self->data->data =0;
26.         return ret;
27.     }
28.    
30.     myListP head =self->data;
31.     head->prev->next = head->next;
32.     head->next->prev=head->prev;
33.     self->data=head->next;
34.     ret = head->data;
36.     self->__head =0; //迭代器重新生成
37.     self->length--;
38.     free(head);
39.     return ret;
40. }
41. static void *pop(myListOP * self){
42.     if (isNullOrEmpty(self))
43.     {
44.         return 0;
45.     }
46.     void*ret;
47.     if (self->data->next == self->data) //只有一个的情况下
48.     {
49.         self->length--;
50.         ret = self->data->data;
51.         self->data->data =0;
52.         return ret;
53.     }
54.     self->length--;
55.     self->__head=0;//迭代器重新生成
56.     myListP current=self->data;
57.     myListP prev=0;
58.     myListP next=0;
59.    
60.     current = current->prev;//定位到尾部
61.     prev=current->prev;
62.     next=current->next;
64.     prev->next=next;
65.     next->prev=prev;
67.     ret=current->data;
68.     current->data=0;
69.     free(current);
70.     return ret;
71. }
73. static myListP slice (myListOP * self,unsigned int i){
74.     if (isNullOrEmpty(self)) //判断是否为空
75.     {
76.         return 0;
77.     }
78.     //期待i在0~.length之间
79.     //区间分成了三段,0,__index,length,查看i离哪个更近
80.     unsigned int distanceFromHead = i;
81.     unsigned int distanceFromTail = self->length - i;
82.     unsigned int distanceFromCurrent = i - self->__index;
83.     distanceFromCurrent=distanceFromCurrent>0?distanceFromCurrent:-distanceFromCurrent;
84.     if (distanceFromHead <= distanceFromTail && distanceFromHead <= distanceFromCurrent)
85.     {
86.         //i离头更近，从头开始遍历
87.         self->__index = 0;
88.         self->__last = self->data;
89.         self->__head = self->data;
90.     }
91.     else if (distanceFromTail < distanceFromHead && distanceFromTail <= distanceFromCurrent)
92.     {
93.         //i离尾更近，从尾开始遍历
94.         self->__index = self->length - 1;
95.         self->__last = self->data->prev;
96.     }
97.     if (self->__head != self->data)
98.     {
99.         self->__index =0;
100.         self->__last = self->data;
101.         self->__head=self->data;
102.     }
103.     if (i == 0)
104.     {
105.         return self->data;
106.     }
107.     for ( ; self->__index < i; self->__index++)
108.     {
109.         self->__last = self->__last->next;
110.         if (self->__last == self->__head)
111.         {
112.             break;
113.         }
114.         
115.     }
116.     for (; self->__index > i; self->__index--)
117.     {
118.         self->__last = self->__last->prev;
119.         if (self->__last == self->__head)
120.         {
121.             break;
122.         }
123.     }
124.     return self->__last == self->data?0:self->__last;
125. }
126. static void* _slice(myListOP * self,unsigned int i){
127.     // 这里是后实现的,为了避免对内部函数进行重构,未对slice方法进行重命名
128.     // 实际用户使用的slice应当为_slice
129.     // 使用的_slice应当为slice
130.     // 2025/5/9 修复可能的段错误
131.     myListP obj = slice(self,i);
132.     return obj?obj->data:obj;
133. }
134. static void*del(struct myListOP*self,unsigned int where){
135.     if (isNullOrEmpty(self))
136.     {
137.         return 0;
138.     }
139.     if (where == 0)
140.     {
141.         return dequeue(self);
142.     }
143.     if (where == self->length-1)
144.     {
145.         return pop(self);
146.     }
147.    
148.     //存在2个以上的元素
149.     myListP last=slice(self,where-1);
150.     myListP current=slice(self,where);
151.     myListP next=slice(self,where+1);
152.     void * ret=0;
153.     last->next=next;
154.     next->prev=last;
155.     ret=current->data;
156.     free(current);
157.     self->length --;
158.     self->__head =0;//迭代器重新生成
159.     return ret;
160. }
161. static int _insertHead(struct myListOP*self,void* data){
162.     if (isNull(self))
163.     {
164.         return 0;
165.     }
166.     if (self->data->data ==0)
167.     {
168.         self->data->data=data;
169.         self->__head =0;//迭代器
170.         self->length++;
171.         return 1;
172.     }
173.     myListP current=(myListP) malloc(sizeof(myList));
174.     current->data=data;
175.     current->next=self->data;
176.     current->prev=self->data->prev;
177.     self->data->prev->next=current;
178.     self->data->prev=current;
179.     self->length++;
180.     // self->data->prev->next=current;
181.     self->data=current; //迭代器重新生成
182.     return 1;
183. }
184. static int append(struct myListOP*self,void* data){
185.     if (isNull(self))
186.     {
187.         return 0;
188.     }
189.     if (self->data->data ==0)
190.     {
191.         self->data->data=data;
192.         self->__head =0;//迭代器
193.         self->length++;
194.         return 1;
195.     }
196.    
197.     myListP current=(myListP) malloc(sizeof(myList));
198.     myListP head = self->data;
199.     current->data=data;
200.     current->next=head;
201.     current->prev=head->prev;
202.     head->prev->next=current;
203.     head->prev=current;
204.     self->__head =0;//迭代器
205.     self->length++;
206.     return 1;
207. }
208. static int insert(struct myListOP*self,unsigned int where,void* data){
209.     if (isNull(self))
210.     {
211.         return 0;
212.     }
213.     if (where ==0 )
214.     {
215.         return _insertHead(self,data);
216.     }
217.     if (where ==self->length )
218.     {
219.         return append(self,data);
220.     }
221.    
222.     myListP last=slice(self,where-1); //最小 where =1
223.     myListP current=(myListP) malloc(sizeof(myList));
224.     myListP next=slice(self,where);
226.     current->data=data;
228.     current->next=next;
229.     current->prev=last;
230.     last->next=current;
231.     next->prev=current;
232.     self->__head =0;
233.     self->length++;
234.     return 1;
235. }
236. static int delAll(struct myListOP*self,unsigned int where){
237.     void * data = del(self,where);
238.     if (data)
239.     {
240.         free(data);
241.         return 1;
242.     }
243.     return 0;
244. }
246. static unsigned int find(struct myListOP*self,void* obj,unsigned int times){
247.     myListP p =0;
248.     unsigned int count =0;
249.     for (unsigned int i = 0; i < -1; i++)
250.     {
251.         p=slice(self,i);
252.         if (p==0)
253.         {
254.             break;
255.         }
256.         if (p->data==obj)
257.         {
258.             if (times == count)
259.             {
260.                 return i;
261.             }
262.             count ++;
263.         }
265.     }
266.     return -1;
267. }
268. static unsigned int findby(struct myListOP*self,int(*cmp)(void*,void*),void*(*filed)(void*),void*target,unsigned int times){//cmp应该返回是否是要找的值
269.     myListP p =0;
270.     unsigned int count =0;
271.     for (unsigned int i = 0; i < -1; i++)
272.     {
273.         p=slice(self,i);
274.         if (p==0)
275.         {
276.             break;
277.         }
278.         if (cmp(filed(p->data),target)==0)
279.         {
280.             if (times == count)
281.             {
282.                 return i;
283.             }
284.             count ++;
285.         }
286.     }
287.     return -1;
288. }
289. static unsigned int unicNoFree (struct myListOP*self,void*(*field)(void*),long unsigned int size,unsigned int times){
290.     unsigned int count=0;
291.     unsigned int ret =0;
292.     for (unsigned int i = 1; i < self->length; i++)
293.     {
294.         count =0;
295.         for (unsigned int j = i+1; j < self->length; j++)
296.         {
297.             if (memcmp(field(slice(self,i)->data),field(slice(self,j)->data),size)==0)
298.             {
299.                 if (count >= times)
300.                 {
301.                     self->delNoFree(self,j);
302.                     j=j-1;
303.                 }
304.                 count=count+1;
305.                 ret = ret+1;
306.             }
307.         }
308.     }
309.     return ret;
310. }
311. static unsigned int unic (struct myListOP*self,void*(*field)(void*),long unsigned int size,unsigned int times){
312.     unsigned int count=0;
313.     unsigned int ret =0;
314.     for (unsigned int i = 1; i < self->length; i++)
315.     {
316.         count =0;
317.         for (unsigned int j = i+1; j < self->length; j++)
318.         {
319.             if (memcmp(field(slice(self,i)->data),field(slice(self,j)->data),size)==0)
320.             {
321.                 if (count >= times)
322.                 {
323.                     self->del(self,j);
324.                     j=j-1;
325.                 }
326.                 count=count+1;
327.                 ret = ret+1;
328.             }
329.         }
330.     }
331.     return ret;
332. }
334. static void print(struct myListOP*self){
337.     // for (unsigned int i = 0; i < self->length; i++)
338.     // {
339.     //     self->__str(self->slice(self,i)->data);
340.     // }
341.     myListP cur=self->data;
342.     if (isNullOrEmpty(self))
343.     {
344.         return;
345.     }
346.     do{
347.         self->__str(cur->data);
348.         cur=cur->next;
349.     }while (cur!=self->data);
350.    
351.     printf("\n");
352. }
354. static void destory (myListOP *self){
355.     for (unsigned int i = 0; i < self->length; i++)
356.     {
357.         self->del(self,0);
358.     }
359.     free(self->data);
360.     self->data=0;
361.     free (self);
362. }
363. static void destoryNoFree (myListOP *self){
364.     for (unsigned int i = 0; i < self->length; i++)
365.     {
366.         del(self,0);
367.     }
368.     // free(self->data);
369.     self->data=0;
370.     free (self);
371. }
372. static void _quickSort(myListOP *self,long int start,long int end,int(*cmp)(void*, void*),void*(*filed)(void*),int reverse){
373.     if (start < end) {
374.         void* base = slice(self, start)->data; // 以要进行排序数组第0个元素为base
375.         int left = start;  // 左指针
376.         int right = end;   // 右指针
378.         while (left < right) {
379.             // 从右向左找，找到比base小的元素
380.             while (left < right && (cmp(filed(slice(self, right)->data), filed(base)) * reverse) >= 0) {
381.                 right--;
382.             }
383.             // 比base小，替换left所在位置的元素
384.             slice(self, left)->data = slice(self, right)->data;
386.             // 从左向右找，找到比base大的元素
387.             while (left < right && (cmp(filed(slice(self, left)->data), filed(base)) * reverse) <= 0) {
388.                 left++;
389.             }
390.             // 比base大，替换right所在位置的元素
391.             slice(self, right)->data = slice(self, left)->data;
392.         }
393.         slice(self, left)->data = base; // 将base放到正确的位置
395.         // 递归排序左右子数组
396.         _quickSort(self, start, left - 1, cmp,filed ,reverse);
397.         _quickSort(self, left + 1, end, cmp,filed, reverse);
398.     }
399. }
400. static void quickSort(myListOP *self,int(*cmp)(void*, void*),void*(*filed)(void*),int reverse){
401.     if (isNullOrEmpty(self))
402.     {
403.         return;
404.     }
405.     return _quickSort(self,0,self->length-1,cmp,filed,reverse);
406. }
409. static unsigned short int mysizeof(char * obj,unsigned short int size,unsigned int i){
410.     if (obj==0||size==0){return 0;}
411.     for (; size>1&&*(char*)(obj+size-1) - *(char*)(obj+size-2)==0; size--);//尾地址为obj+size-1
412.     return size;
413. }
414. static unsigned int pack(myListOP *self,char* buf,unsigned int length,unsigned short int max_size){
415.     return self->packVarLength(self,buf,length,(unsigned short int(*)(void*,unsigned short int ,unsigned int ))mysizeof,max_size);
416. }
417. 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){
418.     //将对象打包成字节流
419.     unsigned int used=0;
420.     void* obj=0;
421.     unsigned short int size=0;
422.     unsigned short int min_buf_len = sizeof(unsigned short int)*2;
423.     self->packed=0;
424.     if (self->pack_use_max_size)
425.     {
426.         min_buf_len =  sizeof(unsigned short int)*3;
427.     }
428.     if (length<min_buf_len)
429.     {
430.         return 0;
431.     }
432.     if (isNullOrEmpty(self))
433.     {
434.         return 0;
435.     }
436.     // 为总大小腾出空间
437.     used+=sizeof(unsigned short int);
438.     if (self->pack_use_max_size)
439.     {
440.         //如果启用最大大小,则为最大大小腾出空间
441.         used+=sizeof(unsigned short int);
442.     }
443.     //再循环写入每个元素
444.     while(obj=self->slice(self,self->__lastPacked++)){
445.         size = sizefun(obj,max_size,self->__lastPacked-1);
446.         if (self->pack_use_max_size)
447.         {
448.             max_size = max_size<size?size:max_size;
449.         }
450.         //需要写入的字节数为size+sizeof（unsigned short int）
451.         //如果写入量超过长度，则返回实际使用量；
452.         if (used+size+sizeof(unsigned short int)>length)
453.         {
454.             *(unsigned short int *)(buf) =used;
455.             if (self->pack_use_max_size)
456.             {
457.                 *(unsigned short int *)(buf+sizeof(unsigned short int)) =max_size;
458.             }
459.             self->__lastPacked--;//回退计数器
460.             return used;//未打包完,返回使用量
461.         }
462.         //否则则写入大小和数据
463.         *(unsigned short int *)(buf+used) =size;
464.         used+=sizeof(unsigned short int);
465.         memcpy(buf+used,obj,size);
466.         used+=size;
467.     }
468.     self->__lastPacked = 0;//这里说明打包完了
469.     *(unsigned short int *)(buf) =used;
470.     if (self->pack_use_max_size)
471.     {
472.         *(unsigned short int *)(buf+sizeof(unsigned short int)) =max_size;
473.     }
474.     self->packed=1;
475.     return used;
476. }
477. myListOP* myListDUnpack(char pack_use_max_size,char* buf,void(*printData)(void*)){
478.     unsigned int total = *(unsigned short int *)buf;//协议包的总大小
479.     if (total<2*sizeof(unsigned short int)+1)//如果比最小的情况还小(一个总大小,一个对象,对象只写入了一个字节)
480.     {
481.         return 0;
482.     }
483.    
484.     unsigned int delta=sizeof(unsigned short int);//偏移量,头两个字节是协议包大小
485.     unsigned int num =0;//总元素数量
486.     unsigned int maxSize = *(unsigned short int *)(buf+delta);//最大元素的大小,假设第一个最大
487.     unsigned int currentSize=0;
489.     //找到要申请的地址的大小
490.     if (pack_use_max_size)
491.     {
492.         maxSize = *(unsigned short int *)(buf+sizeof(unsigned short int));
493.         delta+=sizeof(unsigned short int);
494.     }
496.     // 先获取最大的大小
497.     while (delta<total)//不会出现等于,最少会写入1字节的obj
498.     {
499.         num=num+1;
500.         currentSize = *(unsigned short int *)(buf+delta);
501.         if (maxSize<currentSize)
502.         {
503.             maxSize = currentSize;
504.         }
505.         delta+=currentSize+sizeof(unsigned short int);
506.     }
507.    
508.     delta = sizeof(unsigned short int);
509.     if (pack_use_max_size)
510.     {
511.         delta+=sizeof(unsigned short int);
512.     }
514.     //再申请内存
515.     myListOP* arr = myListDInit(printData);if (arr == 0){return 0;}
516.     arr->pack_use_max_size=pack_use_max_size;//继承原有的格式
517.     while (delta<total)//不会出现等于,最少会写入1字节的obj
518.     {
519.         void* obj=malloc(maxSize);if (obj == 0){return 0;}
520.         currentSize = *(unsigned short int *)(buf+delta);
521.         delta+=sizeof(unsigned short int);
522.         memset(obj,*(char*)(buf+delta+currentSize-1),maxSize);//以最后一个字节初始化
523.         memcpy(obj,buf+delta,currentSize);
524.         delta+=currentSize;
525.         arr->append(arr,obj);//对链表,存的是对象的地址
526.     }
527.     return arr;
528. }
529. static myListOP* unpack(myListOP* self,char* buf,void(*printData)(void*)){
530.     //兼容层
531.     return myListDUnpack(self->pack_use_max_size,buf,printData);
532. }
533. static int delByAddrNoFree(myListOP *self,void* obj,unsigned int times){
534.     if (self==0||self->isNullOrEmpty(self)||obj==0)
535.     {
536.         return 0;
537.     }
538.     do
539.     {
540.         unsigned int where = self->find(self,obj,times);
541.         if (where == -1)
542.         {
543.             break;
544.         }
545.         self->delNoFree(self,where);
546.     } while (times--);
547.     return times;   
548. }
550. static int delByAddr(myListOP *self,void* obj,unsigned int times){
551.     if (self==0||self->isNullOrEmpty(self)||obj==0)
552.     {
553.         return 0;
554.     }
555.     do
556.     {
557.         unsigned int where = self->find(self,obj,times);
558.         if (where == -1)
559.         {
560.             break;
561.         }
562.         self->del(self,where);
563.     } while (times--);
564.     return times;   
565. }
567. static int add(myListOP *self,myListOP *other){
568.     void* obj =0;
569.     unsigned int i =0;
570.     while (obj=other->slice(other,i++))
571.     {
572.         self->append(self,obj);
573.     }
574. }
576. static int sub(myListOP *self,myListOP *other){
577.     int ret =0;
578.     if (self ==0||other ==0)
579.     {
580.         return ret;
581.     }
582.     if (self->isNullOrEmpty(self)||other->isNullOrEmpty(other))
583.     {
584.         return ret;
585.     }
586.     void* obj_self =0;
587.     void* obj_other=0;
588.     unsigned int i =0;
589.     unsigned int j=0;
590.    
591.     while (obj_other=other->slice(other,i++))
592.     {
593.         while (obj_self=self->slice(self,j++))
594.         {
595.             if (obj_other==obj_self)
596.             {
597.                 self->delByAddr(self,obj_self,0);
598.             }
599.         }
600.     }
601. }
602. myListOP* myListDInit(void(*printData)(void*)){
603.     myListOP *self = (myListOP *) malloc(sizeof(myListOP));
604.     if (self ==0)
605.     {
606.         return 0;
607.     }
608.     bzero(self,sizeof(myListOP));
609.     //申请头节点
610.     self->data = (myListP) malloc(sizeof(myList));
611.     if (self->data ==0)
612.     {
613.         return 0;
614.     }
615.     self->data->data=0;
616.     self->data->next=self->data;
617.     self->data->prev=self->data;
618.     self->append=append;
619.     self->del=delAll;
620.     self->delNoFree = del;
621.     self->__str=printData;
622.     self->destory=destory;
623.     self->find=find;
624.     self->findby=findby;
625.     self->insert=insert;
626.     self->isNullOrEmpty=isNullOrEmpty;
627.     self->length=0;
628.     self->slice=_slice;
629.     self->_slice=slice;
630.     self->unic=unic;
631.     self->print=print;
632.     self->dequeue=dequeue;
633.     self->pop=pop;
634.     self->push=(int (*)(struct myListOP*,void* data))append;
635.     self->queue=(int (*)(struct myListOP*,void* data))append;
636.     self->quickSort=quickSort;
637.     self->_quickSort=_quickSort;
638.     self->destoryNoFree=destoryNoFree;
639.     self->unicNoFree=unicNoFree;
640.     self->packVarLength=packVarLength;
641.     self->pack=pack;
642.     self->unpack=unpack;
643.     self->delByAddr = delByAddr;
645.     return self;
646. }
647.    

复制代码

1. doublyList.h

复制代码

1. #ifndef  __MYDOUBLYLIST_STRUCT__
2. #define __MYDOUBLYLIST_STRUCT__
4. /* 双向循环链表,涵盖操作类
5. *  
6. * 用法: 需要外部创建结构体或对象,同时准备好该结构体或对象的打印(print)方法
7. * 请注意:长度从0开始,到length结束
8. * 推荐以以下方式迭代链表
9. * while(obj=.slice(,i++))
10. * 以下划线(_)开头的方法为某一方法的补充,或是低级实现,理想情况下不应当被使用
11. * 以下划线(__)开头的字段为内部实现依赖的字段,不应当被外界改变
12. * 在数组的实现中,部分方法依赖于长度(.length),其长度不应当被改变
13. * 以下操作是合法的
14. * _slice(0),_slice(length),_slice(-1),_slice(length+1)返回值分别为头数据,尾数据,0,0
15. * slice(1),slice(length),返回值分别为头尾节点内存的对象.
16. * 同一个链表操作类操作不同的链表 即op1->fun(op2,agrs) 该结果应该与 op2->fun(op2,agrs) 一致,但无法保证跨链表操作类结果一致
18. * 如需排序/去重/按字段查找,则需准备字段的方法
19. * 如需排序,需要提供比较方法
20. *
21. * 初始 myListOP* mylistOP =  myListDInit((void(*)(void*))printData);
22. * 2025/5/9  修改返回void* 的slice可能段错误的问题
23. * 2025/5/10 修补编译器提示,增加unicNoFree,增加pack与unpack
24. * 2025/5/11 补充测试函数,放弃对单向链表的支持,重命名新增NoFree函数
25. */
26. typedef struct myList{
28. void * data;
29. struct myList * prev;
30. struct myList * next;
31. }myList,* myListP;
33. typedef struct myListOP{
34. myListP data;
35. //判断链是否为空,空返回1,非空返回0
36. int (*isNullOrEmpty)(struct myListOP*);
37. //将obj存放入链表的尾部,成功返回1,失败返回0
38. int (*append)(struct myListOP*,void* data);
39. /*
40. 删除链表上的第where个节点,会自动free该节点指向的对象
41. returnVal: 0失败,1成功
42. */
43. int (*del)(struct myListOP*,unsigned int where);
44. /*
45. 删除链表上的第where个节点,会自动free该节点指向的对象
46. returnVal: 该节点指向的对象的地址
47. */
48. void* (*delNoFree)(struct myListOP*,unsigned int where);
49. /*
50. 在where处插入obj对象
51. returnVal: 0失败,1成功
52. */
53. int (*insert)(struct myListOP*,unsigned int where,void* obj);
54. /*
55. 查找该对象times+1次,返回times+1次所对应的下标,times为0表示取第一个
56. returnVal: where,-1表示未找到该对象
57. */
58. unsigned int (*find)(struct myListOP*self,void* obj,unsigned int times);
59. /*
60. 在链表上保证链表上某个对象最多不出现time+1次,会free对象
61. field:取字段函数,接受链表内存储的对象,返回要排序的字段的地址
62. size:该字段的大小
63. 具体调用:memcmp(field(slice(self,i)->data),field(slice(self,j)->data),size)==0
64. returnVal:删除了几个对象
65. */
66. unsigned int (*unic)(struct myListOP*self,void*(*field)(void*),long unsigned int size,unsigned int times);
67.      /*
68. 在链表上保证链表上某个对象最多不出现time+1次,不会free对象
69. field:取字段函数,接受链表内存储的对象,返回要排序的字段的地址
70. size:该字段的大小
71. 具体调用:memcmp(field(slice(self,i)->data),field(slice(self,j)->data),size)==0
72. returnVal:删除了几个对象
73. */
74. unsigned int (*unicNoFree)(struct myListOP*self,void*(*field)(void*),long unsigned int size,unsigned int times);
75. /*
76. 返回链表内第i个链的地址,不应当被外部调用
77. */
78. myList* (*_slice)(struct myListOP* self,unsigned int i);
79. /*
80. 返回链表内第i个对象的地址
81. 应该被这么用:
82. while(obj=op->slice(op,i++)){
83. do something to op
84. }
85. */
86. void* (*slice)(struct myListOP* self,unsigned int i);
87. // 销毁链表,并且销毁链表内的所有对象(free obj)
88. void (*destory)(struct myListOP *self);
89. // 将链表内的所有对象挨个传给.__str方法,.__str方法应当在初始化时被正确设置为接受对象的地址并进行输出
90. void (*print)(struct myListOP * self);
91. /*
92. field:取字段函数,接受链表内存储的对象,返回要排序的字段的地址
93. cmp: 比较函数,接收target,接受由field产生的字段的地址,返回两个值的差值(cmp(filed(p->data),target))
94. target:要比较的值的地址
95. times:找第times+1个
96. returnVal:找到返回where,没找到返回-1
97. */
98. unsigned int (*findby)(struct myListOP*self,int(*cmp)(void*,void*),void*(*field)(void*),void*target,unsigned int times);
99. //.print会调用这个方法输出链表内的对象(会将每一个对象的地址输入进这个方法)
100. void (*__str)(void*);
101. //删除链表的第一个节点,将其内部存放的对象的地址返回(而不是free)
102. void*  (*dequeue)(struct myListOP* self);
103. //删除链表的尾节点,将其内部存放的对象的地址返回(而不是free)
104. void*  (*pop)(struct myListOP* self);
105. //将obj存放入链表的尾部,成功返回1,失败返回0
106. int  (*push)(struct myListOP*,void* obj);
107. //将obj存放入链表的尾部,成功返回1,失败返回0
108. int  (*queue)(struct myListOP*,void* data);
109. //对链表的一部分进行快速排序
110. void (*_quickSort)(struct myListOP*self,long int start,long int end,int(*cmp)(void*, void*),void*(*filed)(void*),int reverse);
111. //对整个链表快速排序,field:根据对象的哪个字段地址进行排序,cmp接受两个字段的地址,返回两个字段值的差值,reverse为正则正序,为负则倒叙,0不排序
112. void (*quickSort)(struct myListOP *self,int(*cmp)(void*, void*),void*(*filed)(void*),int reverse);
113. //删除整个链表,但不释放链表中的对象
114. void (*destoryNoFree)(struct myListOP*self);
115. //按地址删除某一元素,obj要删除的对象,times删除次数,返回实际删除了几次,不释放obj
116. int (*delByAddr)(struct myListOP *self,void* obj,unsigned int times);
117. /*
118. 将对象打包成字节流,写入到buf,会删除重复的尾字节
119. 字节流格式：unsigened short int used（2字节) unsigened short int datalen(2字节) data
120. 如果.pack_use_max_size != 0,则在used 之后写入该对象的最大大小
121. buf:缓冲区,字节流写入的地址
122. length:缓冲区buf的长度
123. max_size:链表上存储的obj最大的大小(如大小不一致,请使用.packVarLength)
124. returnVal:往缓冲区实际写入的字节数
125. */
126. unsigned int (*pack)(struct myListOP *self,char* buf,unsigned int length,unsigned short int max_size);
127. /*
128. 将对象打包成字节流,写入到buf,会删除重复的尾字节
129. 字节流格式：unsigened short int used（2字节)unsigened short int datalen(2字节) data
130. 如果.pack_use_max_size != 0,则在used 之后写入该对象的最大大小
131. buf:缓冲区,字节流写入的地址
132. length:缓冲区buf的长度
133. size:取size函数,传入obj对象,返回这个对象占用了多少个字节,obj list里存放的对象,max_size:这个对象理应占的最大字节数,i,第i个对象
134. 如果size函数返回了一个比max_size更大的数,那么以size返回的数据的最大值作为max_size被写入
135. returnVal:往缓冲区实际写入的字节数
136. */
137. 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);
138. /*
139. 将字节流解包成对象,会写入尾部的重复字节
140. 字节流格式：unsigened short int used（2字节)unsigened short int datalen(2字节) data
141. 如果.pack_use_max_size != 0,使用used之后的2字节作为最大长度进行创建内存
142. buf:缓冲区,字节流读取的地址
143. printData:返回操作类初始化时需要的printData
144. returnVal:操作类
145. */
146. struct myListOP* (*unpack)(struct myListOP* self,char* buf,void(*printData)(void*));
147. unsigned int length;//链表的长度
148. unsigned int __index;//内部变量,加速slice与_slice的返回
149. unsigned int __lastPacked;//内部变量,记录上次打包的位置
150. char pack_use_max_size;//是否使用最大的元素大小,修改打包的格式
151. char packed;//是否打包完毕
152. myListP __last;//内部变量,加速slice与_slice的返回
153. myListP __head;//内部变量,加速slice与_slice的返回
155. } myListOP;
156. //初始化函数
157. myListOP* myListDInit(void(*printData)(void*));
158. /*
159. 将字节流解包成对象,会写入尾部的重复字节
160. 字节流格式：unsigened short int used（2字节)unsigened short int datalen(2字节) data
161. 如果pack_use_max_size != 0,使用used之后的2字节作为最大长度进行创建内存
162. buf:缓冲区,字节流读取的地址
163. printData:返回操作类初始化时需要的printData
164. returnVal:操作类
165. */
166. myListOP* myListDUnpack(char pack_use_max_size,char* buf,void(*printData)(void*));
167. #endif

复制代码

1. array.c

复制代码

1. // 实现list的头插,尾插,头删,尾删,任意位置删除,任意位置添加
2. #include <stdio.h>
3. #include <string.h>
4. #include "array.h
5. "
6. static int isNull(myArrayOP* self){
7. if (self ==0 || self->data ==0){return 1;}
8. return 0;
9. }
10. static int isNullOrEmpty(myArrayOP* self){
11. if (isNull(self) || self->length ==0)
12. {
13.      return 1;
14. }
15. return 0;
17. }
18. static void* slice(myArrayOP* self,unsigned int i){
19. if (i>= self->length || i<0)
20. {
21.      return 0;
22. }
24. return self->data+self->size*i;
25. }
26. static int del(myArrayOP* self,unsigned int where){
27. if (isNullOrEmpty(self))
28. {
29.      return 0;
30. }//判断是否非空
31. void* data = self->data;
32. if (where > self->length || where <0)
33. {
34.      return 0;
35. }
36. if (self->length == where+1)//如果最后一个,则直接移动length,避免越界
37. {
38.      self->length = self->length-1;
39.      return 0;
40. }
42. for (unsigned int i = where; i < self->length; i++)
43. {
44.      // data->data[i] = data->data[i+1];
45.      memcpy(data+self->size*i,data+self->size*(i+1),self->size);
46. }
47. self->length = self->length-1;
48. return 0;
50. }
51. static void* delNoFree (myArrayOP* self,unsigned int where){
52. if (isNullOrEmpty(self))
53. {
54.      return 0;
55. }//判断是否非空
56. void* ret = malloc(self->size);
57. memcpy(ret,self->slice(self,where),self->size);
58. del(self,where);
59. return ret;
60. }
61. static int insert(myArrayOP* self,unsigned int where,void* obj){
62. if (isNull(self))
63. {
64.      return 0;
65. }//判断是否非空
66. void* data = self->data;
67. if (self->length == self->max_length)
68. {
69.      return 0;
70. }
71. if (where > self->length||where<0)
72. {
73.      return 0;
74. }
76. if (self->length ==0)
77. {
78.      // data->data[0] = obj;
79.      memcpy(data,obj,self->size);
80.      self->length++;
81.      return 1;
82. }
84. for (unsigned int i =self->length ; i > where; i--)
85. {
86.      memcpy(data+self->size*i,data+self->size*(i-1),self->size);
87. }
88. self->length = self->length+1;
89. memcpy(data+where*self->size,obj,self->size);
91. return 1;
92. }
94. static int insertHead(myArrayOP* self,void* num){
95. return insert(self,0,num);
96. }
97. static int insertTail(myArrayOP* self,void* num){
98. if (isNull(self))
99. {
100.      return 0;
101. }//判断是否非空
102. return insert(self,self->length,num);
104. }
105. static int delHead (myArrayOP* self){
106. return del(self,0);
107. }
108. static int delTail (myArrayOP* self){
109. return del(self,self->length);
110. }
111. static void* delHeadNoFree (myArrayOP* self){
112. return delNoFree(self,0);
113. }
114. static void* delTailNoFree (myArrayOP* self){
115. return delNoFree(self,self->length-1);
116. }
117. static unsigned int find(struct myArrayOP*self,void* obj,unsigned int times){
118. void* p =0;
119. unsigned int count =0;
120. for (unsigned int i = 0; i < -1; i++)
121. {
122.      p=slice(self,i);
123.      if (p==0)
124.      {
125.          break;
126.      }
127.      if (p==obj)
128.      {
129.          if (times == count)
130.          {
131.              return i;
132.          }
133.          count ++;
134.      }
136. }
137. return -1;
138. }
139. static unsigned int findby(struct myArrayOP*self,int(*cmp)(void*,void*),void*(*filed)(void*),void*target,unsigned int times){//cmp应该返回是否是要找的值
140. void* p =0;
141. unsigned int count =0;
142. for (unsigned int i = 0; i < -1; i++)
143. {
144.      p=self->slice(self,i);
145.      if (p==0)
146.      {
147.          break;
148.      }
149.      if (cmp(filed(p),target)==0)
150.      {
151.          if (times == count)
152.          {
153.              return i;
154.          }
155.          count ++;
156.      }
157. }
158. return -1;
159. }
160. static unsigned int _index(myArrayOP* self,void* obj){
161. return find(self, obj,0);
162. }
164. static unsigned int unic (struct myArrayOP*self,void*(*field)(void*),unsigned int times){
165. unsigned int count=0;
166. unsigned int ret =0;
167. for (unsigned int i = 1; i < self->length; i++)
168. {
169.      count =0;
170.      for (unsigned int j = i+1; j < self->length; j++)
171.      {
172.          if (memcmp(field(self->slice(self,i)),field(self->slice(self,j)),self->size)==0)
173.          {
174.              if (count >= times)
175.              {
176.                  self->del(self,j);
177.                  j=j-1;
178.              }
179.              count=count+1;
180.              ret = ret+1;
181.          }
182.      }
183. }
184. return ret;
185. }
186. static void print(myArrayOP * self){
187. void* obj;
188. unsigned int i=0;
189. if (isNullOrEmpty(self))
190. {
191.      return;
192. }
193. while (obj=self->slice(self,i++))
194. {
195.      self->__str(obj);
196. }
197. printf("\n");
198. return;
199. }
200. static void destory(myArrayOP *self){
201. if (self ==0)
202. {
203.      return;
204. }
205. if (self->data ==0)
206. {
207.      return;
208. }
209. free (self->data);
210. self->data=0;
211. free(self);
212. }
214. static void _quickSort(myArrayOP *self,long int start,long int end,int(*cmp)(void*, void*),void*(*filed)(void*),int reverse){
215. if (start < end) {
216.      void* base = malloc(self->size);
217.      memcpy(base,slice(self, start),self->size);// 以要进行排序数组第0个元素为base
218.      int left = start;  // 左指针
219.      int right = end;   // 右指针
221.      while (left < right) {
222.          // 从右向左找，找到比base小的元素
223.          while (left < right && (cmp(filed(slice(self, right)), filed(base)) * reverse) >= 0) {
224.              right--;
225.          }
226.          memcpy(slice(self, left),slice(self, right),self->size);
227.          while (left < right && (cmp(filed(slice(self, left)), filed(base)) * reverse) <= 0) {
228.              left++;
229.          }
230.          memcpy(slice(self, right),slice(self, left),self->size);
231.      }
232.      // slice(self, left)->data = base; // 将base放到正确的位置
233.      memcpy(slice(self, left),base,self->size);
234.      free(base);
235.      // 递归排序左右子数组
236.      _quickSort(self, start, left - 1, cmp,filed, reverse);
237.      _quickSort(self, left + 1, end, cmp,filed, reverse);
238. }
239. }
240. static void quickSort(myArrayOP *self,int(*cmp)(void*, void*),void*(*filed)(void*),int reverse){
241. if (isNullOrEmpty(self))
242. {
243.      return;
244. }
245. return _quickSort(self,0,self->length-1,cmp,filed,reverse);
246. }
247. static unsigned short int mysizeof(char * obj,unsigned int size){
248. if (obj==0||size==0){return 0;}
249. for (; size>1&&*(char*)(obj+size-1) - *(char*)(obj+size-2)==0; size--);//尾地址为obj+size-1
250. return size;
251. }
252. static unsigned int pack(myArrayOP *self,char* buf,unsigned int length){
253. //将对象打包成字节流
254. //格式：unsigened short int used（2字节)unsigened short int len(2字节)data
255. //如果定义了宏 __PACK_WRITE_MAXSIZE__,则在used后写入max_size
256. unsigned int used=0;
257. void* obj=0;
258. unsigned short int size=0;
259. unsigned int min_buf_len = sizeof(unsigned short int)*2;
260. self->packed=0;
261. if (self->pack_use_max_size)
262. {
263.      min_buf_len =  sizeof(unsigned short int)*3;
264. }
265. if (length<min_buf_len)
266. {
267.      return 0;
268. }
269. if (isNullOrEmpty(self))
270. {
271.      return 0;
272. }
273. // 为总大小腾出空间
274. used+=sizeof(unsigned short int);
277. if (self->pack_use_max_size)
278. {
279.      *(unsigned short int *)(buf+used) =self->size;
280.      used+=sizeof(unsigned short int);
281. }
282. //再循环写入每个元素
283. while(obj=self->slice(self,self->__lastPacked++)){
284.      size = mysizeof(obj,self->size);
285.      //需要写入的字节数为size+sizeof（unsigned short int）
286.      //如果写入量超过长度，则返回实际使用量；
287.      if (used+size+sizeof(unsigned short int)>length)
288.      {
289.              *(unsigned short int *)(buf) =used;
290.              self->__lastPacked--;//回退计数器
291.              return used;//未打包完,返回使用量
292.      }
293.      //否则则写入大小和数据
294.      *(unsigned short int *)(buf+used) =size;
295.      used+=sizeof(unsigned short int);
296.      memcpy(buf+used,obj,size);
297.      used+=size;
298. }
299. self->__lastPacked = 0;//这里说明打包完了
300. self->packed=1;
301. *(unsigned short int *)(buf) =used;
302. return used;
303. }
304. myArrayOP* myArrayUnpack(char pack_use_max_size,char* buf,void(*printData)(void*)){
305. unsigned int total = *(unsigned short int *)buf;//协议包的总大小
306. if (total<2*sizeof(unsigned short int)+1)//如果比最小的情况还小(一个总大小,一个对象,对象只写入了一个字节)
307. {
308.      return 0;
309. }
311. //先循环遍历,找到最大的元素大小和要申请的地址的大小
312. unsigned int delta=sizeof(unsigned short int);//偏移量,头两个字节是协议包大小
313. unsigned int num =0;//总元素数量
314. unsigned int maxSize = *(unsigned short int *)(buf+delta);//最大元素的大小,假设第一个最大
315. unsigned int currentSize=0;
316. if (pack_use_max_size)
317. {
318.      // 如果有写max_size 则使用
319.      maxSize = *(unsigned short int *)(buf+sizeof(unsigned short int));
320.      delta+=sizeof(unsigned short int);
321. }
323.      while (delta<total)//不会出现等于,最少会写入1字节的obj
324. {
325.      num=num+1;
326.      currentSize = *(unsigned short int *)(buf+delta);
327.      if (maxSize<currentSize)
328.      {
329.          maxSize = currentSize;
330.      }
331.      delta+=currentSize+sizeof(unsigned short int);
332. }
334. delta = sizeof(unsigned short int);
335. //再申请内存
336. myArrayOP* arr = myArrayInit(maxSize*num,maxSize,printData);if (arr == 0){return 0;}
337. //为了方便还原数据,申请maxSize大小的内存;
338. void* obj=malloc(maxSize);if (obj == 0){return 0;}
340. while (delta<total)//不会出现等于,最少会写入1字节的obj
341. {
342.      currentSize = *(unsigned short int *)(buf+delta);
343.      delta+=sizeof(unsigned short int);
344.      memset(obj,*(char*)(buf+delta+currentSize-1),maxSize);//以最后一个字节初始化
345.      memcpy(obj,buf+delta,currentSize);
346.      delta+=currentSize;
347.      arr->append(arr,obj);
348. }
349. free(obj);
350. arr->pack_use_max_size=pack_use_max_size;//继承原有的格式
351. return arr;
352. }
353. static myArrayOP* unpack(myArrayOP* self,char* buf,void(*printData)(void*)){
354. //兼容层
355. return myArrayUnpack(self->pack_use_max_size,buf,printData);
356. }
357. static int delByAddr(myArrayOP *self,void* obj){
358. if (self==0)
359. {
360.      return -1;
361. }
362. if (isNullOrEmpty(self))
363. {
364.      return -1;
365. }
366. if (obj<self->data||obj>(self->data+self->length*self->size))
367. {
368.      return -1;
369. }
370. unsigned int where = (unsigned int)((char*)obj - (char*)self->data)/self->size;
371. self->del(self,where);
372. return where;
373. }
374. static int add(myArrayOP *self,myArrayOP *other){
375. void* obj =0;
376. unsigned int i =0;
377. while (obj=other->slice(other,i++))
378. {
379.      self->append(self,obj);
380. }
381. }
382. static int sub(myArrayOP *self,myArrayOP *other){
383. int ret =0;
384. if (self ==0||other ==0)
385. {
386.      return ret;
387. }
388. if (self->isNullOrEmpty(self)||other->isNullOrEmpty(other))
389. {
390.      return ret;
391. }
392. if (self->size!=other->size) //两个数组中数据大小不一样,不比较
393. {
394.      ret = -1;
395.      return ret;
396. }
397. unsigned int size = self->size;
400. void* obj_self =0;
401. void* obj_other=0;
402. unsigned int i =0;
403. unsigned int j=0;
405. while (obj_other=other->slice(other,i++))
406. {
407.      while (obj_self=self->slice(self,j++))
408.      {
409.          if (memcmp(obj_self,obj_other,size)==0)
410.          {
411.              self->delByAddr(self,obj_self);
412.          }
413.      }
414. }
415. }
417. static myArrayOP* copy(myArrayOP* self){
418. myArrayOP* ret = myArrayInit(self->max_length,self->size,self->__str);
419. memcpy(ret->data,self->data,self->size*self->length);
420. return  ret;
421. }
422. static myArrayOP* setter(myArrayOP* self,myArrayOP*other){
423. memcpy(self->data,other->data,self->size*self->length);
424. return  self;
425. }
426. myArrayOP* myArrayInit(unsigned int max_length,unsigned int size,void(*printData)(void*)){
427. myArrayOP * self = 0;
428. self = (myArrayOP*) malloc(sizeof(myArrayOP));
429. bzero(self,sizeof(myArrayOP));
431. self->data = calloc(max_length,size);
432. // malloc(sizeof(myList));
433. bzero(self->data,sizeof(max_length*size));
434. self->max_length=max_length;
435. self->size=size;
436. self->__str=printData;
437. self->del = del;
438. self->delHead=delHead;
439. self->delTail=delTail;
440. self->delNoFree=delNoFree;
441. self->find=find;
442. self->index=_index;
443. self->insert=insert;
444. self->inserTail=insertTail;
445. self->insertHead=insertHead;
446. self->isNullOrEmpty=isNullOrEmpty;
447. self->slice=slice;
448. self->unic=unic;
449. self->print=print;
450. self->destory=destory;
451. self->delHeadNoFree=delHeadNoFree;
452. self->delTailNoFree=delTailNoFree;
453. self->delNoFree=delNoFree;
454. self->quickSort=quickSort;
455. self->_quickSort=_quickSort;
456. self->append=insertTail;
457. self->push=insertTail;
458. self->queue=insertTail;
459. self->dequeue=delHeadNoFree;
460. self->pop=delTailNoFree;
461. self->findby=findby;
462. self->pack=pack;
463. self->unpack=unpack;
464. self->copy=copy;
465. self->setter = setter;
466. return self;
467. }

复制代码

1. array.h

复制代码

1. #ifndef  __MYARRAYLIST_STRUCT__
2. #define __MYARRAYLIST_STRUCT__
3. #include <stdlib.h>
4. // 数组,堆上的对象数组
5. // 用法: 需要外部创建结构体或对象,同时准备好该结构体或对象的打印(print)方法
6. // 请注意:长度从0开始,到length结束
7. // 推荐以以下方式迭代链表
8. // while(obj=.slice(,i++))
9. // 以下划线(_)开头的方法为某一方法的补充,或是低级实现,理想情况下不应当被使用
10. // 以下划线(__)开头的字段为内部实现依赖的字段,不应当被外界改变
11. // 在数组的实现中,部分方法依赖于长度(.length),其长度不应当被改变
12. // 以下操作是合法的
13. // _slice(0),_slice(length),_slice(-1),_slice(length+1)返回值分别为头数据,尾数据,0,0
14. // slice(1),slice(length),返回值分别为头尾节点内存的对象.
15. // 同一个链表操作类操作不同的链表 即op1->fun(op2,agrs) 该结果应该与 op2->fun(op2,agrs) 一致,但无法保证跨链表操作类结果一致
17. /* 封装测试于2025/4/30,修复部分.length操作
18. *  
19. * 2025/4/16 添加类
20. * 2025/4/16 添加通用的测试方法
21. * 2025/4/25 添加_destory方法,未测试,理应是好的
22. * 2025/4/27 修复findby与quickSort,_quickSort,findby的cmp函数,使其统一,并新增字段field函数,应当返回一对象内部的地址
23. * 2025/4/27 针对有头单项链表测试,修改有头单项链表,定义1-.length为合法操作
24. * 2025/5/9  修补数组,使其对任意的obj有效,重命名新增NoFree函数
25. * 2025/5/10 新增pack和unpack方法,打包/解包成数据流
26. */
27. typedef struct myArrayOP{
28. void* data;  //堆上的数组
29. size_t length; //目前的长度,0为空
30. size_t max_length;//数组的最大长度
31. unsigned int __lastPacked;
32. char pack_use_max_size;//是否使用最大的元素大小
33. char packed;
34. void (*__str)(void*);//打印方法
35. unsigned short int size;//内部每个元素的大小
36. int (*isNullOrEmpty)(struct myArrayOP*);//判断列表是否为空
37. int (*insertHead)(struct myArrayOP*,void* obj);//在数组的头插入
38. int (*inserTail)(struct myArrayOP*,void* obj);//在数组的末尾插入
39. int (*delHead)(struct myArrayOP*);//删除数组的头
40. int (*delTail)(struct myArrayOP*);//删除数组的尾
41. void* (*delHeadNoFree)(struct myArrayOP*);//删除数组的头(不会自动调用free),会copy一份返回
42. void* (*delTailNoFree)(struct myArrayOP*);//删除数组的尾(不会自动调用free),会copy一份返回
43. int (*del)(struct myArrayOP*,unsigned int where);//在数组的where处删除某个对象(会自动调用free)
44. void* (*delNoFree)(struct myArrayOP*,unsigned int where);//在数组的where处删除某个对象(不会自动调用free),会copy一份返回
45. int (*insert)(struct myArrayOP*,unsigned int where,void* obj);//在数组的where处插入对象
46. unsigned int (*index)(struct myArrayOP*,void* obj);//取该对象的数组下标
47. unsigned int (*find)(struct myArrayOP*,void* obj,unsigned int times);//查找该对象times+1次,返回times+1次所对应的下标,times为0表示取第一个
48. 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表示取第一个
49. unsigned int (*unic) (struct myArrayOP*self,void*(*field)(void*),unsigned int times);//在数组上保证数组上某个对象最多不出现time+1次,filed函数应当返回特征字段的地址,size应当设置为特征的大小
50. void* (*slice)(struct myArrayOP* self,unsigned int i);//切片函数,数组上的第i个对象
51. void (*destory)(struct myArrayOP *self);//销毁数组,会释放所有的该数组上的对象
52. // void (*destoryNoFree)(struct myArrayOP *self);
53. void (*print)(struct myArrayOP * self);//使用.__str方法打印数组上的所有对象
54. void (*_quickSort)(struct myArrayOP *self,long int start,long int end,int(*cmp)(void*, void*),void*(*filed)(void*),int reverse);//从start到end的快速排序
55. void (*quickSort)(struct myArrayOP *self,int(*cmp)(void*, void*),void*(*filed)(void*),int reverse);//整个链表的快速排序,cmp方法返回给出的两个对象哪个更大,reverse为正则正序,为负则逆序,0不做排序
56. int (*append)(struct myArrayOP*,void* data);//尾插
57. void*  (*dequeue)(struct myArrayOP* self);//在数组上将第0个元素删除,将元素拷贝一份到新的堆空间并返回拷贝后的地址,需要手动free
58. void*  (*pop)(struct myArrayOP* self);//在数组上将最后一个元素删除,将元素拷贝一份到新的堆空间并返回拷贝后的地址,需要手动free
59. int  (*push)(struct myArrayOP*,void* data);//拷贝该元素到数组的最后一位
60. int  (*queue)(struct myArrayOP*,void* data);//拷贝该元素到数组的最后一位
61. unsigned int (*pack)(struct myArrayOP *self,char* buf,unsigned int length);//将其内部的数据打包成字节流
62. struct myArrayOP* (*unpack)(struct myArrayOP *self,char* buf,void(*printData)(void*));//将字节流解包成内部数据,返回一个新的对象
63. int (*delByAddr)(struct myArrayOP *self,void* obj);//按地址删除某一元素
64. struct myArrayOP *(*copy)(struct myArrayOP *self);//拷贝副本
65. struct myArrayOP *(*setter)(struct myArrayOP *self,struct myArrayOP *other);//将other的数据域拷贝至self的数据域
66. } myArrayOP;
67. //初始化函数
68. myArrayOP* myArrayInit(unsigned int max_length,unsigned int size,void(*print)(void*));
69. /*
70. 将字节流解包成对象,会写入尾部的重复字节
71. 字节流格式：unsigened short int used（2字节)unsigened short int datalen(2字节) data
72. 如果pack_use_max_size != 0,使用used之后的2字节作为最大长度进行创建内存
73. buf:缓冲区,字节流读取的地址
74. printData:返回操作类初始化时需要的printData
75. returnVal:操作类
76. */
77. myArrayOP* myArrayUnpack(char pack_use_max_size,char* buf,void(*printData)(void*));
78. #endif

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。