C 堆栈，运行时类型挷定

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

#if __STDC_VERSION__ >= 199901L
#include <stdbool.h>
#define C99
#else
typedef enum {false, true} bool;
#endif

typedef struct _stack {
size_t size;
size_t capacity;
char * data;
size_t element_size;
}Stack, *pStack;

/**
* specified each element sizt which store in stack.
* return stack pointer.
*/
void * stack_new(size_t element_size);

/**
* Release stack memory
*/
void stack_free(pStack ptr);

/**
* Push value into stack,
*/
bool stack_push(pStack ptr, void * value);

/**
* Pop from stack
*/
void stack_pop(pStack ptr);

/**
* Return the top element of stack
*/
void * stack_top(pStack ptr);

/**
* Return stack size
*/
size_t stack_size(pStack ptr);

typedef struct _stu {
int no;
char name[20];
}Student, *pStudent;

void * stack_new(size_t element_size)
{
pStack ptr = (pStack)calloc(1, sizeof(Stack));
if (NULL == ptr){
fprintf(stderr, "stack allocate error\n");
}
ptr->element_size = element_size;
ptr->data = NULL;
ptr->size = 0;
ptr->capacity = 0;
return ptr;
}

void stack_free(pStack ptr)
{
free(ptr->data);
ptr->size = 0;
free(ptr);
}

bool stack_push(pStack ptr, void * value)
{
if (ptr->data == NULL) {
ptr->data = calloc(1, ptr->element_size);
if (ptr->data == NULL) {
exit(EXIT_FAILURE);
}
memcpy(ptr->data, (char*)value, ptr->element_size);
ptr->size = 1;
} else {
if (ptr->capacity <= ptr->size){
ptr->data = realloc(ptr->data, ptr->size * ptr->element_size + ptr->element_size);
memcpy(ptr->data + ptr->element_size * ptr->size, (char *)value, ptr->element_size);
ptr->size += 1;
ptr->capacity += 1;
} else {
memcpy(ptr->data + ptr->element_size * ptr->size, (char *)value, ptr->element_size);
ptr->size += 1;
}
}
return true;
}

void stack_pop(pStack ptr)
{
ptr->size -= 1;
}

void * stack_top(pStack ptr)
{
return ptr->data + ((ptr->size - 1) * ptr->element_size);
}

size_t stack_size(pStack ptr)
{
return ptr->size;
}

/* Test */
int main(void)
{
int value = 10, v = 11;
Student s1 = {12, "student1"},s2 = {13, "student2"},
s3 = {15, "stu3"}, *sptr;
pStack ps = stack_new(sizeof(Student));
pStack p = stack_new(sizeof(int));

stack_push(p, &value);
stack_push(p, &v);
printf("%d\n", *((int*)stack_top(p)));
stack_pop(p);
printf("%d\n", *((int*)stack_top(p)));
stack_free(p);

stack_push(ps, &s1);
stack_push(ps, &s2);
sptr = (pStudent)stack_top(ps);
printf("no: %d, name: %s\n", sptr->no, sptr->name);
stack_pop(ps);
stack_push(ps, &s3);
sptr = (pStudent)stack_top(ps);
printf("no: %d, name: %s\n", sptr->no, sptr->name);
stack_free(ps);
exit(EXIT_SUCCESS);
}