1 // stack.h 2 // This stack is implemented by void pointer, so it is GENERIC. 3 // 4 // How the void pointer allows assignments of different data types: 5 // first, a normal pointer is binded to a data type, so it knows the number of bytes of the 6 // data it points to. second, it has an address, which is the start-address of the data. 7 // so they can tell the compiler where to start and where to stop accessing the data. 8 // 9 // but void pointer is binded to no data type. it only knows the starting-address.10 // so it can be forcely assigned to any pointers, thus allowing assignments of all data types.11 // so what we do is: when we create the stack, we MALLOC a block of free space, and we take a12 // integer, the typesize, which specifies the length of the data.13 // We use the function MEMCPY, which directly access the addresses,to push the data in the stack14 // and pop data out of the stack.15 //16 // The difference from the definiton:17 // the stack pointer here is different from the definition.18 // when the stack is empty, Top == base.19 // when an element is pushed in, Top points to the address after the last byte of the element.20 // so the Top always points to the next available space.21 22 #include<stdio.h>23 #include<stdlib.h>24 25 struct Record26 {27     void *Top;28     void *base;29     int stacksize;30     size_t typesize;31 };32 33 typedef struct Record *Stack;34 35 Stack CreateStack(int stacksize, size_t typesize);36 void Push(Stack S, void *data);37 void Pop(Stack S, void *data);38 int IsEmpty(Stack S);39 void Clear(Stack S);40 void Destroy(Stack S);

// stack.c#include"stack.h"#include<string.h>Stack CreateStack(int stacksize, size_t typesize){    Stack S = (Stack)malloc(sizeof(struct Record));    S->base = malloc(stacksize*typesize);    if(!S->base)    {        printf("Out of space.\n");        exit(1);    }    S->Top = S->base;    S->stacksize = stacksize;    S->typesize = typesize;    return S;}void Push( Stack S, void *data){    if( (int)(S->Top - S->base) + S->typesize > S->stacksize )    {        printf("Out of space to Push.\n");        exit(1);    }    memcpy(S->Top, data, S->typesize);    S->Top = (void*)( (int)S->Top + S->typesize );}  // GNU defines the arithmetic of void* equals to char(which is defined as byte).  // ANSI says we cannot do arithmetic on void* because we don‘t know the type.  // so when we update the Top pointer, first regard it as an int, and convert it  // back when we are finished.void Pop( Stack S, void *data){    if( S->Top == S->base )    {        printf("Error:Popping an empty stack.\n");        exit(1);    }    S->Top = (void*)( (int)S->Top - S->typesize);    memcpy(data, S->Top, S->typesize);}void Clear(Stack S){    S->Top = S->base;}int IsEmpty(Stack S){    return S->Top == S->base;}void Destroy(Stack S){    free(S->base);}