C语言模拟进栈出栈，先进先出先进后出共用内存

本次程序可用于串口通讯缓存等，起因是UCOS的通知没有达到预想的效果。
本程序主体由一个结构体和三个函数组成：

一个结构体

内存和当前栈内数据长度

typedef struct Stack
{
	int Data[Data_Len];
	int P_Active;    //当前栈长 
} My_Stack_type;

三个函数

第一个函数：进栈

int Stack_Push(My_Stack_type *Stack_Active,int Data) //进栈
从内存数组的0元素开始存数，累加存。

Data Num:0 Data:
进栈成功0=0
Data Num:0 Data:
进栈成功1=10
Data Num:1 Data:0
进栈成功2=20
Data Num:2 Data:0 10
进栈成功3=30
Data Num:3 Data:0 10 20
进栈成功4=40
Data Num:4 Data:0 10 20 30
进栈成功5=50
Data Num:5 Data:0 10 20 30 40
进栈成功6=60
Data Num:6 Data:0 10 20 30 40 50
进栈成功7=70
Data Num:7 Data:0 10 20 30 40 50 60
进栈成功8=80
Data Num:8 Data:0 10 20 30 40 50 60 70
进栈成功9=90
Data Num:9 Data:0 10 20 30 40 50 60 70 80
进栈失败，数据过多
进栈失败，数据过多

第二个函数：先进后出出栈

int Stack_FILO_Pop(My_Stack_type *Stack_Active,int *Data) //先进后出出栈
从内存数组的最后进的数开始出

Data Num:10 Data:0 10 20 30 40 50 60 70 80 90
出栈成功9=90
Data Num:9 Data:0 10 20 30 40 50 60 70 80
出栈成功8=80
Data Num:8 Data:0 10 20 30 40 50 60 70
出栈成功7=70

第三个函数：先进先出出栈

int Stack_FIFO_Pop(My_Stack_type *Stack_Active,int *Data) //先进先出出栈
从最先放入的数据开始出，并将后放入的数据前移

Data Num:7 Data:0 10 20 30 40 50 60
出栈成功0
Data Num:6 Data:10 20 30 40 50 60
出栈成功10
Data Num:5 Data:20 30 40 50 60
出栈成功20
Data Num:4 Data:30 40 50 60

完整例程

#include <stdio.h>

#define Debug_En 0 
#define Data_Len 10
typedef struct Stack
{
	int Data[Data_Len];
	int P_Active;    //当前栈长 
} My_Stack_type;

My_Stack_type My_Stack;

int Stack_Push(My_Stack_type *Stack_Active,int Data)  //进栈 
{
	if(Stack_Active->P_Active<Data_Len)
	{
		Stack_Active->Data[Stack_Active->P_Active]=Data;
		#if Debug_En
			printf("进栈成功%d=%d\r\n",Stack_Active->P_Active,Stack_Active->Data[Stack_Active->P_Active]); 
			Stack_Show(Stack_Active);
		#endif
		Stack_Active->P_Active++;
		return 0; 
	}else{
		#if Debug_En
			printf("进栈失败，数据过多\r\n"); 
		#endif
		return 1;  //数据过多 
	}
}

int Stack_FILO_Pop(My_Stack_type *Stack_Active,int *Data)   //先进后出出栈 
{
	if(Stack_Active->P_Active)
	{
		Stack_Active->P_Active--;
		*Data=Stack_Active->Data[Stack_Active->P_Active];
		#if Debug_En
			printf("出栈成功%d=%d\r\n",Stack_Active->P_Active,*Data); 
			Stack_Show(Stack_Active);
		#endif
		return 0; 
	}else{
		printf("出栈失败，数据为空\r\n"); 
		return 1;  //数据过多 
	}
}
int Stack_FIFO_Pop(My_Stack_type *Stack_Active,int *Data)   //先进先出出栈 
{
	int i=0;
	if(Stack_Active->P_Active)
	{
		*Data=Stack_Active->Data[0];
		#if Debug_En
			printf("出栈成功%d\r\n",*Data);
		#endif
		for(i=0;i<Stack_Active->P_Active;i++)
		{
			Stack_Active->Data[i]=Stack_Active->Data[i+1];
		}
		Stack_Active->P_Active--;
		#if Debug_En
			Stack_Show(Stack_Active);
		#endif
		return 0; 
	}else{
		#if Debug_En
			printf("出栈失败，数据为空\r\n"); 
		#endif
		return 1;  //数据过多 
	}
}
int Stack_Show(My_Stack_type *Stack_Active)//打印内存 
{
	int i=0;
	printf("Data Num:%d Data:",Stack_Active->P_Active);
	for(i=0;i<Stack_Active->P_Active;i++)
	{
		printf("%d ",Stack_Active->Data[i]);
	}
	printf("\r\n");
}


int main(int argc, char *argv[])
{
	int i=0;
	int Data;
	Stack_Show(&My_Stack);
	for(i=0;i<12;i++)
	{
		Stack_Push(&My_Stack,i*10);
	}
	Stack_Show(&My_Stack);
	for(i=0;i<3;i++)
	{
		Stack_FILO_Pop(&My_Stack,&Data);
	}
	Stack_Show(&My_Stack);
	for(i=0;i<3;i++)
	{
		Stack_FIFO_Pop(&My_Stack,&Data);
	}
	Stack_Show(&My_Stack);
	for(i=0;i<12;i++)
	{
		Stack_Push(&My_Stack,i*10);
	}
	Stack_Show(&My_Stack);
	for(i=0;i<3;i++)
	{
		Stack_FILO_Pop(&My_Stack,&Data);
	}
	Stack_Show(&My_Stack);
	for(i=0;i<20;i++)
	{
		Stack_FIFO_Pop(&My_Stack,&Data);
	}
	Stack_Show(&My_Stack);
	return 0;
}

实际运行截图

Data Num:0 Data:
进栈成功0=0
Data Num:0 Data:
进栈成功1=10
Data Num:1 Data:0
进栈成功2=20
Data Num:2 Data:0 10
进栈成功3=30
Data Num:3 Data:0 10 20
进栈成功4=40
Data Num:4 Data:0 10 20 30
进栈成功5=50
Data Num:5 Data:0 10 20 30 40
进栈成功6=60
Data Num:6 Data:0 10 20 30 40 50
进栈成功7=70
Data Num:7 Data:0 10 20 30 40 50 60
进栈成功8=80
Data Num:8 Data:0 10 20 30 40 50 60 70
进栈成功9=90
Data Num:9 Data:0 10 20 30 40 50 60 70 80
进栈失败，数据过多
进栈失败，数据过多
Data Num:10 Data:0 10 20 30 40 50 60 70 80 90
出栈成功9=90
Data Num:9 Data:0 10 20 30 40 50 60 70 80
出栈成功8=80
Data Num:8 Data:0 10 20 30 40 50 60 70
出栈成功7=70
Data Num:7 Data:0 10 20 30 40 50 60
Data Num:7 Data:0 10 20 30 40 50 60
出栈成功0
Data Num:6 Data:10 20 30 40 50 60
出栈成功10
Data Num:5 Data:20 30 40 50 60
出栈成功20
Data Num:4 Data:30 40 50 60
Data Num:4 Data:30 40 50 60
进栈成功4=0
Data Num:4 Data:30 40 50 60
进栈成功5=10
Data Num:5 Data:30 40 50 60 0
进栈成功6=20
Data Num:6 Data:30 40 50 60 0 10
进栈成功7=30
Data Num:7 Data:30 40 50 60 0 10 20
进栈成功8=40
Data Num:8 Data:30 40 50 60 0 10 20 30
进栈成功9=50
Data Num:9 Data:30 40 50 60 0 10 20 30 40
进栈失败，数据过多
进栈失败，数据过多
进栈失败，数据过多
进栈失败，数据过多
进栈失败，数据过多
进栈失败，数据过多
Data Num:10 Data:30 40 50 60 0 10 20 30 40 50
出栈成功9=50
Data Num:9 Data:30 40 50 60 0 10 20 30 40
出栈成功8=40
Data Num:8 Data:30 40 50 60 0 10 20 30
出栈成功7=30
Data Num:7 Data:30 40 50 60 0 10 20
Data Num:7 Data:30 40 50 60 0 10 20
出栈成功30
Data Num:6 Data:40 50 60 0 10 20
出栈成功40
Data Num:5 Data:50 60 0 10 20
出栈成功50
Data Num:4 Data:60 0 10 20
出栈成功60
Data Num:3 Data:0 10 20
出栈成功0
Data Num:2 Data:10 20
出栈成功10
Data Num:1 Data:20
出栈成功20
Data Num:0 Data:
出栈失败，数据为空
出栈失败，数据为空
出栈失败，数据为空
出栈失败，数据为空
出栈失败，数据为空
出栈失败，数据为空
出栈失败，数据为空
出栈失败，数据为空
出栈失败，数据为空
出栈失败，数据为空
出栈失败，数据为空
出栈失败，数据为空
出栈失败，数据为空
Data Num:0 Data: