/* 堆疊的長度在建立堆疊的函式被呼叫時給出，該函式必須在任何其他操作堆疊的函式被呼叫之前呼叫 */    
#include <stdio.h>    
#include <assert.h>    
#include <stdlib.h>    
    
#define STACK_TYPE int /* 堆疊所儲存的值的資料型別 */      
    
/* 用於儲存堆疊元素的陣列和指向堆疊頂部元素的指標 */      
static STACK_TYPE *stack;    
static int stack_size;    
static int top_element = -1;    
    
/*   
   建立對棧，引數指定對棧可以儲存多少個元素   
   注意：此函式只適用於動態分配陣列形式的堆疊。  
 */    
void create_stack (size_t size);    
    
/*  
   銷燬一個堆疊，釋放堆疊所適用的記憶體  
   注意，此函式只適用於動態分配陣列和連結串列結構的堆疊。  
 */    
void destroy_stack (void);    
    
/* 將一個新值壓入堆疊中，引數是被壓入的值。*/      
void push (STACK_TYPE value);    
    
/* 彈出堆疊中棧頂的一個值，並丟棄。*/      
void pop (void);    
    
/* 返回堆疊頂部元素的值，但不改變堆疊結構。*/      
STACK_TYPE top (void);    
    
/* 如果堆疊為空，返回TRUE,否則返回FALSE。*/     
int is_empty (void);    
    
/* 如果堆疊為滿，返回TRUE,否則返回FALSE。*/      
int is_full (void);    
    
/* 自定義函式實現遍歷操作 */    
void travel (void);    
    
/* 計算棧中元素的個數 */    
int size (void);    
    
int main (void)    
{    
    create_stack (50);    
    travel ();      
    pop ();      
    printf("%s\n", is_empty() ? "棧為空" : "棧未空");       
    
    int i = 0;      
    for (i = 0; i <= 9; i++)      
    {      
        push (i);      
    }      
    puts ("push 壓棧後的數值為: ");      
    travel ();      
    printf ("此時棧頂元素為：%d\n", top ());      
    printf ("此時棧元素個數為：%d\n", size ());      
    
    pop ();      
    pop ();      
      
    puts ("經過pop彈出幾個元素後的棧元素： ");      
    travel ();      
    
    printf("%s\n", is_full() ? "棧為滿" : "棧未滿");      
    printf("%s\n", is_empty() ? "棧為空" : "棧未空");       
          
    printf ("此時棧頂元素為：%d\n", top ());      
    printf ("此時棧元素個數為：%d\n", size ());      
    destroy_stack ();    
    printf ("此時棧元素個數為：%d\n", size ());      
    return 0;      
}    
    
void create_stack (size_t size)    
{    
    //assert (stack_size == 0);    
    if (size < stack_size)    
    {    
        printf ("棧元素個數太少\n");    
        return ;    
    }    
    stack_size = size;    
    stack = (STACK_TYPE *)malloc (stack_size * sizeof (STACK_TYPE));    
    if (NULL == stack)    
        perror ("malloc分配失敗"), exit (1);    
}    
    
void destroy_stack (void)    
{    
    //assert (stack_size > 0);    
    if (stack != NULL)    
    {    
		printf ("銷燬堆疊\n");
        stack_size = 0;    
        free (stack);    
        stack = NULL;    
        top_element = -1;    
    }  
}    
    
void push (STACK_TYPE value)    
{    
    //assert (!is_full ());    
    if (is_full ())    
    {    
        printf ("棧已滿，入棧失敗\n");      
        return ;    
    }    
    top_element += 1;    
    stack[top_element] = value;    
}    
    
void pop (void)    
{    
    //assert (!is_empty ());    
    if (is_empty ())      
    {      
        printf ("棧已空，出棧失敗\n");      
        return ;      
    }      
    top_element -= 1;    
}    
    
STACK_TYPE top (void)    
{    
    //assert (!is_empty ());    
    if (is_empty ())    
    {    
        printf ("棧已空，出棧失敗\n");    
        return ;    
    }    
    return stack[top_element];    
}    
    
int is_empty (void)    
{    
    //assert (stack_size > 0);    
    if (stack != NULL)    
    {    
        return top_element == -1;    
    }    
}    
    
int is_full (void)    
{    
    //assert (stack_size > 0);    
    if (stack != NULL)    
    {    
        return top_element == stack_size - 1;    
    }  
}    
    
void travel (void)    
{    
    int i = 0;      
    if (top_element == -1)      
        printf ("這個棧為空");      
    for (i = 0; i <= top_element; i++)      
        printf ("%d ", stack[i]);      
    printf ("\n");     
}    
    
int size (void)    
{    
    return top_element + 1;    
}    
輸出結果：
這個棧為空
棧已空，出棧失敗
棧為空
push 壓棧後的數值為: 
0 1 2 3 4 5 6 7 8 9 
此時棧頂元素為：9
此時棧元素個數為：10
經過pop彈出幾個元素後的棧元素： 
0 1 2 3 4 5 6 7 
棧未滿
棧未空
此時棧頂元素為：7
此時棧元素個數為：8
銷燬堆疊
此時棧元素個數為：0