STL_Queue.cpp STL_Queue.h D:/gitt/MicrochipFor32/STL_Device/STL_Queue.cpp STL_Queue.h varint.h stdint.h stdlib.h 实现了STL库中的Queue /*---------------------------------------------------------------------------------------------------- # #Copyright(c)2022YuankangLiang(XerolySkinner) # #本软件按原样提供,无任何明示或暗示 #在任何情况下,作者都不承担任何损害赔偿责任 # #使用的许可声明: #1.不得歪曲本软件的来源,你不能声称你编写了原始软件. #2.免费授予以任何目的,前提是版权声明出现在所有副本中. #并且版权声明和许可声明同时出现. #3.你有使用,复制,修改,分发,和销售本软件的许可. #4.如果你在产品中使用,产品文档中的声明是赞赏的但不是必须的. #5.本通知不得从任何来源删除或更改. # #YuankangLiang(XerolySkinner) #E-mail:zabbcccbbaz@163.com #QQ:2715099320 #MobilePhone:13005636215 # #Allrightsreserved. */ //---------------------------------------------------------------------------------------------------- //头文件 #include"STL_Queue.h" //---------------------------------------------------------------------------------------------------- //构造函数 STL_rQueue::STL_rQueue(void){ room=0; size=0; dat=NULL;} //---------------------------------------------------------------------------------------------------- STL_rQueue::~STL_rQueue(void){ free(dat);} //---------------------------------------------------------------------------------------------------- //成员函数 u8STL_rQueue::push(u8var){ //保存分配前的数据头 u8*temp_stacks=dat; //若所需空间小于现有空间 if(size>=room){ //分配新长度 dat=static_cast<u8*>(realloc(dat,++size)); //分配失败,善后并且返回错误 if(dat==NULL){ --size;//恢复原长度 dat=temp_stacks;//恢复数据 returnQUEUES_REAL_ERROR;}//返回错误 room=size; //分配成功,压入数据 dat[size-1]=var; //返回正确指数 returnQUEUES_OK;} //空间剩余,压入数据 dat[(++size)-1]=var; //返回正确指数 returnQUEUES_OK;} //---------------------------------------------------------------------------------------------------- u8STL_rQueue::pop(void){ //若数据队列中大于1,缩短成员空间 if(size>1){ //整体移动掉一位 for(u32i=0;i<size-1;i++) *(dat+i)=*(dat+i+1); --size;//重新分配成员空间 returnQUEUES_OK;} //若数据队列中等于1,重指定头 elseif(size==1){ size=0;//重新分配成员空间 returnQUEUES_OK;}//若数据队列为空,返回空队列错误号 else returnQUEUES_EMPTY;} //---------------------------------------------------------------------------------------------------- u8STL_rQueue::top(u8&var){ if(size){ var=dat[0]; returnQUEUES_OK;} returnQUEUES_EMPTY;} //---------------------------------------------------------------------------------------------------- u32STL_rQueue::The_size(void){ returnsize;} //---------------------------------------------------------------------------------------------------- u32STL_rQueue::The_room(void){ returnroom;} //---------------------------------------------------------------------------------------------------- u8STL_rQueue::clean(void){ //保存分配前的数据头 u8*temp_stacks=dat; //如果有成员,重新分配空间 if(size){ //重新分配空间 dat=static_cast<u8*>(realloc(dat,size)); //分配失败,善后并返回错误 if(dat==NULL){ --size;//恢复原长度 dat=temp_stacks;//恢复数据 returnQUEUES_REAL_ERROR;}//返回错误 } //无成员队列重新分配成员 else{ free(dat);//释放全部空间 dat=NULL; size=0;}//重指定首部 //无数据返回空队列 room=size;//新的空间大小 returnQUEUES_OK;} //---------------------------------------------------------------------------------------------------- u8STL_rQueue::push32(u32var){ push(((u8*)(&var))[3]); push(((u8*)(&var))[2]); push(((u8*)(&var))[1]); push(((u8*)(&var))[0]); returnQUEUES_OK;} //---------------------------------------------------------------------------------------------------- u8STL_rQueue::poptop(void){ u8var=0; top(var);pop(); returnvar;} //---------------------------------------------------------------------------------------------------- u32STL_rQueue::poptop32(void){ u8dat[4]={0,0,0,0}; top(dat[3]);pop(); top(dat[2]);pop(); top(dat[1]);pop(); top(dat[0]);pop(); return*((u32*)(dat));} //---------------------------------------------------------------------------------------------------- void(*STL_rQueue::poptopfun(void))(void){ return(void(*)(void))poptop32();} //---------------------------------------------------------------------------------------------------- voidSTL_rQueue::pushfun(void(*fun)(void)){ push32((u32)fun);} //---------------------------------------------------------------------------------------------------- //构造函数 STL_lQueue::STL_lQueue(void){ STL_lQueue::Hdat=NULL; STL_lQueue::Tdat=NULL; STL_lQueue::mem=0; } STL_lQueue::~STL_lQueue(void){ if(mem)pop();} //---------------------------------------------------------------------------------------------------- //成员函数 u8STL_lQueue::push(void*&var,u32size){ _lQueue*newdat=(_lQueue*)malloc(sizeof(_lQueue)); if(newdat==NULL)returnQUEUES_MALL_ERROR; newdat->dat=var; newdat->size=size; newdat->back=NULL; if(mem==0){ Hdat=newdat; Tdat=newdat;} else{ Hdat->back=newdat; Hdat=newdat;} ++mem; returnQUEUES_OK;} //---------------------------------------------------------------------------------------------------- u8STL_lQueue::pop(void){ if(mem==0)returnQUEUES_EMPTY; _lQueue*savedat=Tdat;//保存尾部 if(mem==1){ Tdat=NULL; Hdat=NULL;} elseif(mem>1){ Tdat=Tdat->back;} free(savedat->dat); free(savedat); --mem; returnQUEUES_OK;} //---------------------------------------------------------------------------------------------------- u8STL_lQueue::top(void*&var,u32&size){ if(mem==0)returnQUEUES_EMPTY; var=Tdat->dat; size=Tdat->size; returnQUEUES_OK;} //---------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------- u8STL_lQueue::push8(u8var){ void*num=(u8*)malloc(sizeof(u8)); if(num==NULL)returnQUEUES_MALL_ERROR; *(u8*)num=var; push(num,sizeof(u8)); returnQUEUES_OK;} //---------------------------------------------------------------------------------------------------- u8STL_lQueue::top8(u8&var){ void*vars=NULL; u32sizes=0; if(top(vars,sizes)==QUEUES_EMPTY) returnQUEUES_EMPTY; var=*((u8*)vars); returnQUEUES_OK;} //---------------------------------------------------------------------------------------------------- u8STL_lQueue::poptop8(void){ u8temp=0; top8(temp); pop(); returntemp;} //---------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------- u8STL_lQueue::push32(u32var){ void*num=(u32*)malloc(sizeof(u32)); if(num==NULL)returnQUEUES_MALL_ERROR; *(u32*)num=var; push(num,sizeof(u32)); returnQUEUES_OK;} //---------------------------------------------------------------------------------------------------- u8STL_lQueue::top32(u32&var){ void*vars=NULL; u32sizes=0; if(top(vars,sizes)==QUEUES_EMPTY) returnQUEUES_EMPTY; var=*((u32*)vars); returnQUEUES_OK;} //---------------------------------------------------------------------------------------------------- u32STL_lQueue::poptop32(void){ u32temp=0; top32(temp); pop(); returntemp;} //---------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------- u8STL_lQueue::pushfun(void(*fun)(void)){ u8res; res=push32((u32)fun); returnres;} //---------------------------------------------------------------------------------------------------- void(*STL_lQueue::poptopfun(void))(void){ return(void(*)(void))poptop32();}