1. 首页
  2. 文章中心
  3. # 数据结构

【数据结构】【C语言】存放任何数据，动态数组定义和实现

62 阅读 0 评论
我是靠谱客的博主 激情书本，最近开发中收集的这篇文章主要介绍【数据结构】【C语言】存放任何数据，动态数组定义和实现，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

前言

最近做编译器，需要一些容器，直接用数组或指针或内存太危险！所以需要用容器封装一下！

//动态数组
struct iarray {
	void** content;			    //指针数组，每个元素都是指针，指针无论类型长度都是一样的，4或8
	size_t size;				//当前元素个数
	size_t capacity;		    //容器内当前最大可容纳的元素个数
};

/*iarray*/


//创建动态数组
ipublic struct iarray* iarray_create();

//插入元素
ipublic void iarray_push(struct iarray* _array, void* _data);

//删除最后一个元素并返回
ipublic void* iarray_pop(struct iarray* _array);

//根据位置删除元素
ipublic void iarray_del(struct iarray* _array, size_t _position);

//根据值删除元素,删除所有同值的元素
ipublic void iarray_remove(struct iarray* _array, BOOL(*judge)(void*));

//根据值删除元素的递归删除函数
iprivate void iarray_remove_recursion(struct iarray* _array, size_t _start, BOOL(*judge)(void*));

//清空数组
ipublic void iarray_clear(struct iarray* _array);

//释放内存
ipublic void iarray_destory(struct iarray* _array);

//查找元素,返回元素
ipublic void* iarray_find(const struct iarray* _array, BOOL(*judge)(void*));

//获取元素
ipublic void* iarray_at(const struct iarray* _array, size_t _position);

//获取容量，用函数封装为了进行安全检查
ipublic size_t iarray_capacity(const struct iarray* _array);

//获取个数，用函数封装为了进行安全检查
ipublic size_t iarray_size(const struct iarray* _array);

//打印数组
ipublic void iarray_show(const struct iarray* _array, void(*show)(void*));




//创建动态数组
ipublic struct iarray* iarray_create() {
	struct iarray* arr = (struct iarray*)malloc(sizeof(struct iarray));
	arr->size = 0;
	arr->capacity = 4;
	arr->content = (void**)malloc(sizeof(void*) * arr->capacity);
	return arr;
}





//插入元素
ipublic void iarray_push(struct iarray* _array, void* _data) {
	if (_array == NULL) {
		ierr("[iarray_push] dynamic array is null");
		return;
	}

	//空间是否足够
	if (_array->capacity == _array->size) { //空间不足

		//更新容量
		//新空间是旧空间2倍，后期增长变慢
		if (_array->capacity <= 128)
			_array->capacity = (size_t)(_array->capacity * 2);
		else
			_array->capacity = (size_t)(_array->capacity * 1.2);


		//申请一块更大的空间		
		void** space = (void**)malloc(sizeof(void*) * _array->capacity);

		//拷贝数据到新空间
		memcpy(space, _array->content, _array->capacity * sizeof(void*));

		//释放旧空间内存
		free(_array->content);

		//更新新空间
		_array->content = space;

	}


	//加入新元素
	_array->content[_array->size] = _data;
	++_array->size;

}





//删除最后一个元素并返回
ipublic void* iarray_pop(struct iarray* _array) {
	if (_array == NULL || _array->size == 0) {
		ierr("[iarray_push] dynamic array is null");
		return NULL;
	}
	--_array->size;
	return _array->content[_array->size];
}


//根据位置删除元素
ipublic void iarray_del(struct iarray* _array, size_t _position) {
	if (_array == NULL || _array->size <= 0) {
		ierr("[iarray_del] dynamic array is null");
		return;
	}

	//检查位置是否有效
	if (_position >= _array->size || _position < 0) {
		ierr("[iarray_del] _position out of range");
		return;
	}

	//把后面的元素向前移动一格
	for (size_t i = _position; i < _array->size - 1; ++i) {
		_array->content[i] = _array->content[i + 1];
	}

	//更新个数
	--_array->size;


}




//根据值删除元素
ipublic void iarray_remove(struct iarray* _array, BOOL(*judge)(void*)) {
	if (_array == NULL || _array->size <= 0) {
		ierr("[iarray_remove] dynamic array is null");
		return;
	}

	//找到值，然后递归移动，后面的值移动一格，一旦遇到相同的值，再递归移动一次
	iarray_remove_recursion(_array, 0, judge);
}


//根据值删除元素的递归删除函数
iprivate void iarray_remove_recursion(struct iarray* _array, size_t _start, BOOL(*judge)(void*)) {
	if (_array == NULL || _array->size <= 0) {
		ierr("[iarray_remove_recursion] bidirectionla circulate list is null");
		return;
	}



	//检查位置是否有效
	if (_start >= _array->size || _start < 0) {
		ierr("[iarray_remove_recursion] _start out of range");
		return;
	}

	for (size_t i = _start; i < _array->size; ++i) {
		if (judge(_array->content[i]) == TRUE) {
			//先移动
			iarray_del(_array, i);

			//最后一个元素也是这个值，就不用递归了
			if (i == _array->size)return;

			//再递归，看看后面还有没有这个值
			iarray_remove_recursion(_array, i, judge);
			return;
		}
	}
}




//清空数组
ipublic void iarray_clear(struct iarray* _array) {
	if (_array == NULL) {
		ierr("[iarray_clear] dynamic array is null");
		return;
	}

	_array->size = 0;
}




//释放内存
ipublic void iarray_destory(struct iarray* _array) {
	if (_array == NULL) {
		ierr("[iarray_free] dynamic array is null");
		return;
	}

	if (_array->content != NULL) {
		free(_array->content);
	}
	_array->capacity = 0;
	_array->size = 0;
	_array = NULL;
	free(_array);
}




//查找元素
ipublic void* iarray_find(const struct iarray* _array, BOOL(*judge)(void*)) {
	if (_array == NULL || _array->size <= 0) {
		ierr("[iarray_find] dynamic array is null");
		return -1;
	}

	//查找值，返回第一个
	for (size_t i = 0; i < _array->size; ++i) {
		if (judge(_array->content[i]) == TRUE) {
			return _array->content[i];
		}
	}

	ierr("[iarray_find] can not find the value ");
	return NULL;//没有找到
}



//获取元素
ipublic void* iarray_at(const struct iarray* _array, size_t _position) {
	if (_array == NULL || _array->size <= 0) {
		ierr("[iarray_at] dynamic array is null");
		return -1;
	}

	return _array->content[_position];
}



//获取容量，用函数封装为了进行安全检查
ipublic size_t iarray_capacity(const struct iarray* _array) {
	if (_array == NULL || _array->size < 0) {
		ierr("[iarray_capacity] dynamic array is null");
		return -1;
	}

	return _array->capacity;
}



//获取个数，用函数封装为了进行安全检查
ipublic size_t iarray_size(const struct iarray* _array) {
	if (_array == NULL || _array->size < 0) {
		ierr("[iarray_size] dynamic array is null");
		return -1;
	}

	return _array->size;
}




//打印数组
ipublic void iarray_show(const struct iarray* _array, void(*show)(void*)) {
	if (_array == NULL || _array->size <= 0) {
		ierr("[iarray_size] dynamic array is null");
		return;
	}

	printf("array : n");
	for (size_t i = 0; i < _array->size; ++i) {
		printf("%4d", i);
	}
	printf("n");
	for (size_t i = 0; i < _array->size; ++i) {
		show(_array->content[i]);
	}
	printf("n");
}

使用方法

//数据节点
struct MyData {
	size_t age;
};


void display(void* _data) {
	struct MyData* d = (struct MyData*)_data;
	printf("%4lu", d->age);
}

BOOL determine(void* _data) {
	struct MyData* d = (struct MyData*)_data;
	if (d->age == 12)return TRUE;
	return FALSE;
}



int main(void) {

	/*------------Begin-------------*/

	struct iarray* arr = iarray_create();
	struct MyData a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11;

	a0.age = 13;
	iarray_push(arr, &a0);

	a1.age = 7;
	iarray_push(arr, &a1);

	a2.age = 2;
	iarray_push(arr, &a2);

	a3.age = 12;
	iarray_push(arr, &a3);

	a4.age = 15;
	iarray_push(arr, &a4);

	a5.age = 1;
	iarray_push(arr, &a5);

	a6.age = 12;
	iarray_push(arr, &a6);

	a7.age = 4;
	iarray_push(arr, &a7);

	a8.age = 12;
	iarray_push(arr, &a8);

	a9.age = 1;
	iarray_push(arr, &a9);

	a10.age = 8;
	iarray_push(arr, &a10);

	a11.age = 345;
	iarray_push(arr, &a11);



	printf("size:%lun", iarray_size(arr));
	iarray_show(arr, display);

	iarray_del(arr, 3);

	printf("size:%lun", iarray_size(arr));
	iarray_show(arr, display);

	//
	//
	//printf("%dn", sizeof(void*));
	//printf("%dn", sizeof(void**));
	//printf("%dn", sizeof(int*));
	//printf("%dn", sizeof(struct iarray*));

	/*------------End---------------*/

	return 0;
}

最后

以上就是激情书本为你收集整理的【数据结构】【C语言】存放任何数据，动态数组定义和实现的全部内容，希望文章能够帮你解决【数据结构】【C语言】存放任何数据，动态数组定义和实现所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(41)

相关文章

python 操作excel 样式
python 操作excel 样式
C# 使用窗体读取Excel表格数据最简单粗暴的方法
C# 使用窗体读取Excel表格数据最简单粗暴的方法
阿里图库，svg资源总结
阿里图库，svg资源总结
创建动态数组
创建动态数组
【数据结构】【C语言】存放任何数据，动态数组定义和实现
【数据结构】【C语言】存放任何数据，动态数组定义和实现
【VBA】数组介绍vba数组详解
【VBA】数组介绍vba数组详解
vba给数组赋值
vba给数组赋值
C语言初学练习
C语言初学练习

评论列表共有 0 条评论

立即
投稿
返回
顶部