C语言使用 void 指针实现栈模板

数据结构基础课的教材使用C来实现数据结构，上学期看别的书用C++实现时还没什么感觉，一对比就发现C++的类和模板用起来比C方便多了。

在写四则运算计算器的时候，int写一遍，char还得写一遍感觉十分痛苦，百度了一下有没有别的解决办法，发现了下面这篇文章。

如何利用堆栈及逆波兰表达式进行数学四则运算：http://www.xuebuyuan.com/1602553.html

关键是在于理解 void 指针与一般指针的不同之处是它只保存数据的首地址，而不知道也不关心数据究竟有多少个字节。

因此利用 memcpy 可以无视数据类型进行赋值，这就让我们能够创建多种类型的Stack。

由于 memcpy 的参数是 void 指针，所以Push和Pop的都只接受地址作为参数，并且直接将改变应用于相应的内存单元，并不返回值。

此外，此处实现的Top指针也和一般的Stack定义不同，此处的Top指针总是指向下一个可用的内存单元。

仿照着写了一个Stack的实现如下：

// This stack is implemented by void pointer, so it is GENERIC.
//
// How the void pointer allows assignments of different data types:
//    first, a normal pointer is binded to a data type, so it knows the
//    number of bytes of the data it points to. second, it has an address,
//    which is the start-address of the data. so they can tell the compiler
//    where to start and where to stop accessing the data.
//
//    but void pointer is binded to no data type,it only knows the starting-address.
//    so it can be forcely assigned to any pointers, thus allowing assignments of
//    all data types. so what we do is: when we create the stack, we MALLOC a block
//    of free space, and we take an integer of 'size_t', the typesize, which
//    specifies the length of the data. We use the function MEMCPY, which directly
//    access the addresses,to push the data in the stack and pop data out.
//
// The difference from the definiton:
//    the stack pointer here is different from the definition.
//    when the stack is empty, top == base.
//    when an element is pushed in, top points to the address after the last byte
//    of the element. so the top always points to the next available space.

#include<stdio.h>
#include<stdlib.h>

struct Record
{
    void *top;
    void *base;
    int stacksize;
    int typesize;
};

typedef struct Record *Stack;

Stack CreateStack(int stacksize, size_t typesize);
void Push(Stack S, void *data);
void Pop(Stack S, void *data);
int IsEmpty(Stack S);
void Clear(Stack S);
void Destroy(Stack S);

#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);
}