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

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

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

前言

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

复制代码
1
2
3
4
5
6
7
//动态数组
struct iarray {
	void** content;			    //指针数组，每个元素都是指针，指针无论类型长度都是一样的，4或8
	size_t size;				//当前元素个数
	size_t capacity;		    //容器内当前最大可容纳的元素个数
};
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
/*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*));
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249



//创建动态数组
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");
}

使用方法

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
//数据节点
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语言】存放任何数据内容请搜索靠谱客的其他文章。

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

相关文章

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

评论列表共有 0 条评论

立即
投稿
返回
顶部