C实现看起来像泛型的顺序表

最新推荐文章于 2025-12-18 20:15:21 发布

原创最新推荐文章于 2025-12-18 20:15:21 发布 · 145 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#c语言 #数据结构 #链表

文章展示了如何在不支持泛型编程的C语言中，利用void*和位操作实现顺序表的基本操作，如初始化、查找、插入、删除和销毁。代码包括了InitList、Length、LocateElem、GetElem、ListInsert、ListDelete等函数的实现，并在main函数中进行了测试。

顺序表的简单操作 ADT

C前面的版本是不支持泛型编程的，以前学习数据结构的时候采用C++来做的泛型编程，就想着能不能用C来做一次试试，C的void*可以一定程度上实现泛型，实现逻辑主要是依靠位操作，把所有数据类型转换为字符型来操作，最后获取元素的时候再按照不同的类型来解释即可。

#pragma once
typedef struct {
	int maxSize;
	int elemSize;
	void* array;
	int length;
}List;
typedef enum {
	false,true
}bool;
bool InitList(List* list, int size, int elemSize);
int Length(List);
int LocateElem(List, void*);
void* GetElem(List, int);
bool ListInsert(List*, int, void*);
bool ListDelete(List*, int, void*);
void Print(List);
bool Empty(List);
bool DestroyList(L

接口的实现，初始化，按照值查找，返回元素

bool InitList(List* list, int size,int elemSize) {
	list->maxSize = size;
	list->array = malloc(size*elemSize);
	list->length = 0;
	list->elemSize = elemSize;
}//初始化操作
int Length(List list) {
	return list.length;
}//返回数组长度
int LocateElem(List list, void* val) {
	char* bytes = (char*)list.array;
	char* target = (char*)&val;
	for (int i = 0; i < list.length; i++) {
		if (!memcmp(bytes + list.elemSize * i, target, list.elemSize)) {
			return i;
		}
	}
	return -1;
}//返回数据元素的位置
void* GetElem(List list, int index) {
	char* bytes = (char*)list.array;
	return bytes + index * list.elemSize;
}//获取返回元素，最后接收元素的时候需要强转类型

插入元素，删除元素

bool ListInsert(List*list , int index, void* val) {
	if (index<0 || index>list->length + 1)
		return false;//这是是我自定义的枚举类型，可看上方ADT
	char* bytes = (char*)list->array;
	memmove(bytes + (index + 1) * list->elemSize, bytes + index * list->elemSize,(list->length-index)*list->elemSize);//先移动元素，空出位置，由于是泛型，因此统一转为字符型来进行位操作
	memmove(bytes + index * list->elemSize, &val,list->elemSize);
	list->length++;//线性表长度递增
	return true;
}
bool ListDelete(List*list, int index, void* val) {
	if (index > list->length || index < 0) {
		return false;
	}
	char* bytes = (char*)list->array;
	memmove(val, bytes + index * list->elemSize, list->elemSize);
	memmove(bytes + index * list->elemSize, bytes + (index + 1) * list->elemSize, (list->length - index - 1) * list->elemSize);
	list->length--;
	return true;
}//与插入原理相同

判空以及销毁顺序表

bool Empty(List list) {
	if (list.length == 0) {
		return false;
	}
	else
		return true;
}
bool DestroyList(List* list) {
	memset(list->array, 0, list->length * list->elemSize);
	free(list->array);
	list->array = NULL;
	list->length = 0;
	return true;
}

测试

int main() {
	List mylist;
	InitList(&mylist, 5, sizeof(int));
	ListInsert(&mylist, 0, 5);
	ListInsert(&mylist, 1, 6);
	ListInsert(&mylist, 0, 7);
	int a=0;
	ListDelete(&mylist, 0, &a);
	int k = LocateElem(mylist, 6);
	int* m = (int*)GetElem(mylist, 1);
	printf("该位置元素为: %d\n", *m);
	printf("该元素位于: %d\n", k);
	printf("删除的元素为 : %3d\n", a);
	printf("删除后顺序表长度： %3d\n", Length(mylist));
	DestroyList(&mylist);//销毁
	printf("销毁后长度： %3d\n", Length(mylist));
	system("pause");
	return 0;
}