支持泛型的c语言栈

上一篇文章中我以Swap函数为例写了如何在用C语言写出支持泛型的函数，这一篇我将写一个支持泛型的C语言栈。

栈---如果学过C语言或数据结构的话，对这个概念并不陌生，我就不再啰嗦写出栈的特点或特性，我这篇文章的主题是写出支持泛型的栈，具体的技巧还是在上一篇文章中写的那个方法。http://blog.csdn.net/u011362822/article/details/30734971

下面先看一下普通的C语言栈：

头文件：Stack.h

#ifndef C_STACK_HEADER_H
#define C_STACK_HEADER_H

#define MAX_SIZE 50   //该值代表了该栈的最大元素数

typedef struct
{
	int logicalSize;// 当前的元素数
	int allocSize;  // 分配的长度，即栈中最大的元素数
	int* element;
}Stack;


void StackNew(Stack* S);                  // 初始化一个新栈
void StackDel(Stack* S);                  // 删除一个栈
void StackPush(int e, Stack* S);          // 压入一个元素
int StackPop(Stack* S);                   // 弹出一个元素

#endif

源文件：Stack.c

#include <stdlib.h>
#include <assert.h>
#include <stddef.h>
#include "Stack.h"


static void StackReallocate(Stack* S)
{
	int* p = (int*)malloc(2 * S->allocSize * sizeof(int));
	assert(p != NULL);

	int i = 0;
	for (i = 0; i < S->allocSize; i++)
	{
		p[i] = S->element[i];
	}

	S->allocSize *= 2;
	free(S->element);
	S->element = p;
}

void StackNew(Stack* S)
{
	S->allocSize = MAXSIZE;
	S->logicalSize = 0;
	S->element = (int*)malloc(MAXSIZE * sizeof(int));
	assert(S->element != NULL);
}

void StackDel(Stack* S)
{
	free(S->element);
	//free(S); // S的内容不是动态申请的，所以这一步不能要
}

void StackPush(int E, Stack* S)
{
	if (S->logicalSize == S->allocSize)
	{
		StackReallocate(S);
	}
	S->element[S->logicalSize] = E;
	S->logicalSize++;
}

int StackPop(Stack* S)
{
	assert(S->logicalSize > 0);

	S->logicalSize--;

	return S->element[S->logicalSize];
}

支持泛型的栈：支持自增长机制，即栈满后，会自动扩容，见Stack.c中的StackGrow函数

头文件：Stack.h

#ifndef C_STACK_HEADER_H
#define C_STACK_HEADER_H

#define INIT_LENGTH 20

typedef struct
{
	void* elems;    // 指向数据区的指针
	int elemSize;   // 元素的长度
	int loglength;  // 当前的长度
	int alloclength;// 分配的长度

}Stack;

void StackNew(Stack* S, int elemSize);    // 初始化一个栈
void StackDispose(Stack* S);              // 销毁一个栈
void StackPush(Stack* S, void* elemAddr); // 向栈中压入一个元素
void StackPop(Stack* S, void* elemAddr);  // 从栈中弹出一个元素

#endif

源文件：Stack.c

#include <stdlib.h>
//#include <stddef.h>
#include <assert.h>
#include <string.h>
#include "Stack.h"

// 当分配的空间满了后，调用该函数重新分配一个两倍长的空间
static void StackGrow(Stack* S)
{
	S->alloclength *= 2;

	// 该函数会重新分配一个空间，并将原来空间中的元素复制到新空间中
	S->elems = realloc(S->elems, S->alloclength * S->elemSize);
}


void StackNew(Stack* S, int elemSize)
{
	S->elemSize = elemSize;
	S->alloclength = INIT_LENGTH;
	S->loglength = 0;
	S->elems = malloc(INIT_LENGTH * elemSize);
	assert(S->elems != NULL);
}


void StackDispose(Stack* S)
{
	free(S->elems);
}


void StackPush(Stack* S, void* elemAddr)
{
	if (S->loglength == S->alloclength)
	{
	    // 当存满后启动自增长
		StackGrow(S);
	}

	void* target = (char*)S->elems + S->loglength * S->elemSize;
	memcpy(target, elemAddr, S->elemSize);

	S->loglength++;
}



void StackPop(Stack* S, void* elemAddr)
{
	void* source = (char*)S->elems + (S->loglength - 1) * S->elemSize;
	memcpy(elemAddr, source, S->elemSize);

	S->loglength--;
}