基于C语言栈的简易实现方式和应用

一、基本概念
栈是只能在一端进行插入和删除的线性表，栈具有后进先出或先进后出的特性。插入和删除的一端称为栈顶，另一端称为栈底。常见的栈操作入栈和出栈。本文主要介绍我在系统中使用的C操作栈的简易版本

二、栈的运算
1、初始化栈

#define pt_stack(T,size) \
struct{\
	T buf[size];\
	int top;\
}

#define pt_stack_init() \
{.top = -1;}\

2、判断栈的长度

#define pt_stack_len(s) (sizeof((s)->buf)/sizeof((s)->buf[0]))

3、判断栈的数量

#define pt_stack_cap(s)  ((s)->top + 1)

4、判断栈是否为空

#define pt_stack_empty(s) ((s)->top == -1)

5、判读栈是否满

#define pt_stack_full(s) ((s)->top == pt_stack_len(s) - 1)

6、复位栈

#define pt_stack_reset(s) ((s)->top = -1)

7、入栈

#define pt_stack_push(s,el)\
(!pt_stack_full(s) && ((s)->buf[++(s)->top] = el),1)

8、出栈

#define pt_stack_pop(s)\
(pt_stack_empty(s) ? null : (&(s)->buf[(s)->top--]))

9、取栈顶元素

#define pt_stack_peek(s)\
(pt_stack_empty(s) ? null : &(s)->buf[(s)->top])

三、栈的应用

1、栈-结构定义

typedef pt_stack(PAGE*, SIZE)  PAGE_STACK;//<栈结构定义
static PAGE_STACK page_stack = pt_stack_init();//<栈实体
static PAGE **__pages[SIZE];//<栈缓冲区

2、页面-缓冲区（后续根据页面缓冲区查找指定所在的位置）

在这里插入代码片
static int __page_register(void)
{
    static LOCK_SCREEN_PAGE __lock_screen_page;
    lock_screen_page_init(&__lock_screen_page);
    __pages[__page_size++] = (PAGE*)&__lock_screen_page;
    
    static MAIN_PAGE __main_page;
    main_page_init(&__main_page);
    __pages[__page_size++] = (PAGE*)&__main_page;
    
    static MENU_PAGE __menu_page;
    menu_page_init(&__menu_page);
    __pages[__page_size++] = (PAGE*)&__menu_page;
        
    static SYS_SEARCH_MENU_PAGE __sys_search_menu_page;
    sys_search_menu_page_init(&__sys_search_menu_page);
    __pages[__page_size++] = (PAGE*)&__sys_search_menu_page;
    

    static HISTORY_RECORD_PAGE __history_record_page;
    history_record_page_init(&__history_record_page);
    __pages[__page_size++] = (PAGE*)&__history_record_page;
    
       
    static GROUP_NETWORK_INFO_PAGE __group_network_info_page;
    network_info_page_init(&__group_network_info_page);
    __pages[__page_size++] = (PAGE*)&__group_network_info_page;
    
      
    DEVICE_RECORD_PAGE *__device_record_page = MALLOC(sizeof(DEVICE_RECORD_PAGE));
    device_record_page_init(__device_record_page);
    __pages[__page_size++] = (PAGE*)__device_record_page;
    //...后续添加自己相关的即可
}

3、栈-应用

PAGE **page = NULL;
page  = pt_stack_peek(&page_stack );//<取栈顶元素
pt_stack_empty(&page_stack );//<判断栈是否为空
page  = pt_stack_pop(&page_stack );//<出栈
pt_stack_push(&page_stack , page);//<入栈

PAGE* page_mgr_lookup_by_type(PAGE_TYPE type)
{
    PAGE *page = NULL;
    for(int i=0; i<__page_size; ++i){
        page = __pages[i];
        if(page->register_flag && page->type == type){
            return page;
        }
    }
    return NULL;
}


int page_mgr_open_new(PAGE_TYPE type)
{
    int ret = -1;
    PAGE *page = page_mgr_lookup_by_type(type);
    PAGE **cur_page = NULL;
    
    if(page == NULL){
        return -1;
    }
	
	// 当页面存在的时候, 页面类型去重
	cur_page = pt_stack_peek(&page_stack);
	if(cur_page){
		if((*cur_page)->type == type){
			return -2;
		}
	}
    if(page->init_flag == 0){
        if(page->v_table.tp_gui_create){
            ret = page->v_table.tp_gui_create(page);
        }
    }
    else {
        // 不需要动态创建
        ret = 0;
    }
    
    if(ret == 0){
        
        page->init_flag = 1;
        
        // 旧页面隐藏
        if(cur_page && (*cur_page)->v_table.tp_gui_hidden){
            ret = (*cur_page)->v_table.tp_gui_hidden((*cur_page));
        }
        /* 新页面入栈 */
        pt_stack_push(&page_stack, page);
        if(page->v_table.tp_gui_show){
            ret = page->v_table.tp_gui_show(page);
        }
    }
    return ret;
}



int page_mgr_back_open(void)
{
	int ret = 0;
    PAGE **cur_page = NULL;
    PAGE **prev_page = NULL;
    
    if(__page_mgr_init_flag == 0){
        return -1;
    }

	taskENTER_CRITICAL();
	
    cur_page = pt_stack_pop(&page_stack);
    if(cur_page == NULL){
		ret = -1;
        LOGGER(LVL_ERROR, "page stack pop error", __func__);
        goto clean;
    }
    
    prev_page = pt_stack_peek(&page_stack);
    if(prev_page == NULL){
		ret = -2;
        LOGGER(LVL_ERROR, "page stack pop error", __func__);
        goto clean;
    }
    
    if((*cur_page)->mem_type == PERMANENT_PAGE_TYPE){
        // 常驻内存页面
        if((*cur_page)->v_table.tp_gui_hidden){
            (*cur_page)->v_table.tp_gui_hidden(*cur_page);
        }
                
    }
    else {

        // 清理页面
        if((*cur_page)->v_table.tp_gui_cleanup){
            (*cur_page)->v_table.tp_gui_cleanup(*cur_page);
        }
        
        // 动态内存页面
        if((*cur_page)->v_table.tp_gui_delete){
            (*cur_page)->v_table.tp_gui_delete(*cur_page);
        }
        
        (*cur_page)->init_flag = 0;
    }
    
    // 显示前一个页面
    if((*prev_page)->v_table.tp_gui_show){
        (*prev_page)->v_table.tp_gui_show(*prev_page);
    }
	
clean:
	taskEXIT_CRITICAL();
    return ret;
}

以上就是关于栈在页面管理时的使用，在其他应用上也可以类似的做法方便管理