c语言实现任何数据类型的vector(动态数组)

 已经重新整理，并且拆分成多文件，阅读更方便

  跳转链接

面向对象方式重写源码

函数众多都只是简单测试了，不保证没有BUG，有兴趣的可以拷贝下来测试

众所周知vector是C++中的，但c没有所以就写了这个，尽量将名字都写成一样的，好方便后期使用

因为c没有模板这个概念，所以此代码为了实现所有数据类型，本身是无类型的，采用内存拷贝实现。

内置函数获取的数据都是以void指针的形式返回，需要强转成自己使用的类型。

目录

内置函数

插入函数

void Vector_Push_Back(vector* vec, void* x);// 向量尾部增加一个元素X

void Vector_insert_front(struct vector* vec, const void* p, const void* x);// 向量中指向元素p前增加一个元素x

void Vector_insert_nfront(struct vector* vec, const void* p, const int n, const void* x);// 向量中指向元素p前增加n个相同的元素x

void Vector_insert(struct vector* vec, const void* p, const void* p1, const void* p2);// 向量中指向元素p前插入另一个相同类型向量的指针[p1,p2)间的数据

删除函数

void Vector_pop_back(struct vector* vec);//删除向量中最后一个元素

void Vector_erase_p(struct vector* vec, const void* p1, const void* p2);//删除指针区间内的数据

void Vector_erase_int(struct vector* vec, const int left, const int right);//删除区间内的数据

void Vector_clear(struct vector* vec);//清空vector的队列，释放内存

遍历函数

void* Vector_at(const struct vector* vec, int i);// 返回元素的指针，以数组下标形式访问

void* Vector_front(const struct vector* vec);//返回向量头指针，指向第一个元素

void* Vector_back(const struct vector* vec);//返回向量尾指针，指向向量最后一个元素

void* Vector_find(const struct vector* vec, const void* val);//查找数据，返回找到的指针，没有返回NULL

判断函数 

bool Vector_empty(const struct vector* vec);//检测vector内是否为空，空为真 O(1)

大小函数

int Vector_size(const struct vector* vec);//返回vector内元素的个数 O(1)

int  Vector_capacity(const struct vector* vec);//返回当前向量所能容纳的最大元素值

其他函数

void  Vector_sort(struct vector* vec,bool (*Sort)(void *x,void *y));//排序

void Vector_swap(struct vector*vec1, struct vector*vec2);//交换两个同类型向量的数据

初始化函数

void VectorInitial(vector* vec, int n);//初始化函数

测试结果

完整代码

vector.h(头文件)

vector.c(函数实现)

test.c(测试代码)

---

内置函数

插入函数

void Vector_Push_Back(vector* vec, void* x);// 向量尾部增加一个元素X

void Vector_Push_Back(vector* vec,void* x)// 向量尾部增加一个元素X
{
	Capacity(vec);
	char* str1 = (char*)vec->_date + vec->_type * vec->_current;
	memcpy(str1,x, vec->_type);
	vec->_current++;
}

void Vector_insert_front(struct vector* vec, const void* p, const void* x);// 向量中指向元素p前增加一个元素x
 

void Vector_insert_front(vector* vec,const void* p, const void* x)// 向量中指向元素p前增加一个元素x
{
	Capacity(vec);
	if (p >= vec->front(vec) && p <= vec->back(vec))
	{
		int size = (char*)vec->back(vec) - p + vec->_type;
		void* ptr = malloc(size);
		memcpy(ptr, p, size);
		memcpy(p, x, vec->_type);
		memcpy((char*)p + vec->_type, ptr, size);
		vec->_current++;
		free(ptr);
	}
}

void Vector_insert_nfront(struct vector* vec, const void* p, const int n, const void* x);// 向量中指向元素p前增加n个相同的元素x

void Vector_insert_nfront(vector* vec, const void* p, const int n, const void* x)// 向量中指向元素p前增加n个相同的元素x
{
	if (p >= vec->front(vec) && p <= vec->back(vec))
	{
		Capacity(vec);
		int size = (char*)vec->back(vec) - p + vec->_type;
		void* ptr = malloc(size);
		memcpy(ptr, p, size);
		int sizen= ((char*)p-vec->front(vec))/vec->_type;
		for (size_t i = 0; i < n; i++)
		{
			Capacity(vec);
			memcpy((char*)vec->at(vec,sizen), x, vec->_type);
			sizen++;
			vec->_current++;
		}
		memcpy((char*)vec->at(vec, sizen), ptr, size);
		free(ptr);
	}
}

void Vector_insert(struct vector* vec, const void* p, const void* p1, const void* p2);// 向量中指向元素p前插入另一个相同类型向量的指针[p1,p2)间的数据

void Vector_insert(vector* vec, const void* p, const void* p1, const void* p2)// 向量中指向元素p前插入另一个相同类型向量的指针[p1,p2)间的数据
{
	if (p >= vec->front(vec) && p <= vec->back(vec))
	{
		Capacity(vec);
		int size = (char*)vec->back(vec) - p + vec->_type;
		void* ptr = malloc(size);
		memcpy(ptr, p, size);
		int sizen = ((char*)p - vec->front(vec)) / vec->_type;
		int push_n = ((char*)p2 - (char*)p1) / vec->_type+1;
		for (size_t i = 0; i < push_n; i++)
		{
			Capacity(vec);
			memcpy((char*)vec->at(vec, sizen),(char*)p1+i*vec->_type, vec->_type);
			sizen++;
			vec->_current++;
		}
		memcpy((char*)vec->at(vec, sizen), ptr, size);
		free(ptr);
	}
}

删除函数

void Vector_pop_back(struct vector* vec);//删除向量中最后一个元素

void Vector_pop_back(struct vector* vec)//删除向量中最后一个元素
{
	vec->_current--;
}

void Vector_erase_p(struct vector* vec, const void* p1, const void* p2);//删除指针区间内的数据

void Vector_erase_p(struct vector* vec, const void* p1, const void* p2)//删除指针区间内的数据
{
	if (p1<=p2&&vec->front(vec)<=p1&&p2<=vec->back(vec))
	{
		memcpy(p1, (char*)p2 + vec->_type,(int)((char*)vec->back(vec)-(char*)p2));
		vec->_current -= (((int)((char*)p2 - (char*)p1))/vec->_type+1);
	}
}

void Vector_erase_int(struct vector* vec, const int left, const int right);//删除区间内的数据

void Vector_erase_int(struct VECTOR* vec, const int left, const int right)//删除区间内的数据
{
	if (left <= right && left >= 0 && right < vec->_current)
	{
		memcpy(vec->at(vec,left),vec->at(vec,right+1),(vec->_current-1-right)*vec->_type);
		vec->_current -= (right - left + 1);
	}
}

void Vector_clear(struct vector* vec);//清空vector的队列，释放内存

void Vector_clear(struct vector* vec)//清空vector的数组，释放内存
{
	free(vec->_date);
	vec->_date = NULL;
	vec->_current = 0;
	vec->_size = 0;
}

遍历函数

void* Vector_at(const struct vector* vec, int i);// 返回元素的指针，以数组下标形式访问

void* Vector_at(const struct vector* vec, int i)// 返回元素的指针
{
	if (i+1 > vec->_current)
	{
		return NULL;
	}
    return (void*)((char*)vec->_date + vec->_type * i);
}

void* Vector_front(const struct vector* vec);//返回向量头指针，指向第一个元素

void* Vector_front(const struct vector* vec)//返回向量头指针，指向第一个元素
{
	return vec->_date;
}

void* Vector_back(const struct vector* vec);//返回向量尾指针，指向向量最后一个元素

void* Vector_back(const struct vector* vec)//返回向量尾指针，指向向量最后一个元素
{
	char* _date = (char*)vec->_date + vec->_type * (vec->_current-1);
	return _date;
}

void* Vector_find(const struct vector* vec, const void* val);//查找数据，返回找到的指针，没有返回NULL

void* Vector_find(const struct vector* vec, const void* val)//查找数据，返回找到的指针，没有返回NULL
{
	for (int i = 0; i < vec->size(vec); i++)
	{
		if (memcmp(vec->at(vec, i), val, vec->_type) == 0)
		{
			return vec->at(vec, i);
		}
	}
	return NULL;
}

判断函数 

bool Vector_empty(const struct vector* vec);//检测vector内是否为空，空为真 O(1)

bool Vector_empty(const struct vector* vec)//检测vector内是否为空，空为真 O(1)
{
	return !vec->_current;
}

大小函数

int Vector_size(const struct vector* vec);//返回vector内元素的个数 O(1)

int Vector_size(const struct vector* vec)//返回vector内元素的个数 O(1)
{
	return vec->_current;
}

int  Vector_capacity(const struct vector* vec);//返回当前向量所能容纳的最大元素值

int  Vector_capacity(const struct vector* vec)//返回当前向量所能容纳的最大元素值
{
	return vec->_size;
}

其他函数

void  Vector_sort(struct vector* vec,bool (*Sort)(void *x,void *y));//排序

void  Vector_sort(struct vector* vec, bool (*Sort)(void* x, void* y))//排序
{
	qsort(vec->_date, vec->_current, vec->_type, Sort);//使用内置排序函数
}

void Vector_swap(struct vector*vec1, struct vector*vec2);//交换两个同类型向量的数据

void Vector_swap(struct vector* vec1, struct vector* vec2)//交换两个同类型向量的数据
{
	swap(&vec1->_date, &vec2->_date, sizeof(void*));
	swap(&vec1->_current, &vec2->_current, sizeof(int));
	swap(&vec1->_size, &vec2->_size, sizeof(int));
}

初始化函数

void VectorInitial(vector* vec, int n);//初始化函数

void VectorInitial(vector* vec, int n)
{
	vec->clear = Vector_clear;//清空vector的队列，释放内存
	vec->push_back = Vector_Push_Back;//尾插
	vec->insert_front = Vector_insert_front;// 向量中指向元素p前增加一个元素x
	vec->insert_nfront = Vector_insert_nfront;// 向量中指向元素p前增加n个相同的元素x
	vec->insert = Vector_insert;// 向量中指向元素p前插入另一个相同类型向量的指针[p1,p2)间的数据
	vec->pop_back = Vector_pop_back;//尾删
	vec->erase_p = Vector_erase_p;//删除指针区间内的数据
	vec->erase_int = Vector_erase_int;//删除区间内的数据
	vec->at = Vector_at;//返回指定位置的指针
	vec->front = Vector_front;//返回向量头指针，指向第一个元素
	vec->back = Vector_back;//返回向量尾指针，指向向量最后一个元素
	vec->find = Vector_find;//查找数据，返回找到的指针，没有返回NULL
	vec->empty = Vector_empty;//检测vector内是否为空，空为真 O(1)
	vec->size = Vector_size;//返回vector内元素的个数 O(1)
	vec->capacity = Vector_capacity;//返回当前向量所能容纳的最大元素值
	vec->sort = Vector_sort;//排序
	vec->swap = Vector_swap;//交换两个同类型向量的数据
	vec->_type = n;
	vec->_current = 0;
	vec->_date = malloc(vec->_type * VECTORNUM);
	if (vec->_date == NULL)
	{
		perror("初始化vector失败");
		exit(-1);
	}
	else
	{
		vec->_size = VECTORNUM;
	}
}

测试结果

完整代码

vector.h(头文件)

#pragma once
#define _CRT_SECURE_NO_DEPRECATE  1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<stdbool.h>
#include <stdarg.h> 
#define VECTORNUM 4//初始数组大小
typedef struct vector
{
	//插入函数
	void(*push_back)(struct vector* vec, void*);//尾插
	void (*insert_front)(struct vector*, const void*p, const void* x);// 向量中指向元素p前增加一个元素x
	void (*insert_nfront)(struct vector*, const void* p,const int n, const void* x);// 向量中指向元素p前增加n个相同的元素x
	void (*insert)(struct vector*, const void* p, const void* p1, const void* p2);// 向量中指向元素p前插入另一个相同类型向量的指针[p1,p2)间的数据
	//删除函数
	void (*pop_back)(struct vector* );//尾删
	void (*erase_p)(struct vector*,const void*,const void*);//删除指针区间内的数据
	void (*erase_int)(struct vector*,const int,const int);//删除区间内的数据
	void (*clear) (struct vector*);//清空vector的队列，释放内存
	//遍历函数
	void* (*at)(const struct vector*, int);// 返回第0-n个元素的指针
	void* (*front)(const struct vector*);// 返回向量头指针，指向第一个元素
	void* (*back)(const struct vector*);//返回向量尾指针，指向向量最后一个元素
	void* (*find)(const struct vector* vec, const void* val, bool(*fi)(const void* val1,const void* val2));//查找数据，返回找到的指针，没有返回NULL
	//判断函数
	bool (*empty)(const struct vector*);// 检测vector内是否为空，空为真 O(1)
	//大小函数
	int (*size)(const struct vector*);//返回vector内元素的个数 O(1)
	int (*capacity)(const struct vector*); //返回当前向量所能容纳的最大元素个数
	//其他函数
	void (*sort)(struct vector*, int (*Sort)(void* , void* ));//排序
	void (*swap)(struct vector*, struct vector*);//交换两个同类型向量的数据
}vector;
void Vector_clear(vector* vec);//清空vector的队列，释放内存
void Vector_Push_Back(vector* vec, void* x);// 向量尾部增加一个元素X
void Vector_insert_front(vector* vec, const void* p, const void* x);// 向量中指向元素p前增加一个元素x
void Vector_insert_nfront(vector* vec, const void* p, const int n, const void* x);// 向量中指向元素p前增加n个相同的元素x
void Vector_insert(vector* vec, const void* p, const void* p1, const void* p2);// 向量中指向元素p前插入另一个相同类型向量的指针[p1,p2]间的数据
void Vector_pop_back(vector* vec);//删除向量中最后一个元素
void Vector_erase_p(vector* vec, const void* p1, const void* p2);//删除指针区间内的数据
void Vector_erase_int( vector* vec, const int left, const int right);//删除区间内的数据
void* Vector_at(const vector* vec, int i);// 返回元素的指针
void* Vector_front(const  vector* vec);//返回向量头指针，指向第一个元素
void* Vector_back(const  vector* vec);//返回向量尾指针，指向向量最后一个元素
void* Vector_find(const vector* vec, const void* val, bool(*fi)(const void* val1, const void* val2));//查找数据，返回找到的指针，没有返回NULL
bool Vector_empty(const  vector* vec);//检测vector内是否为空，空为真 O(1)
int Vector_size(const  vector* vec);//返回vector内元素的个数 O(1)
int  Vector_capacity(const  vector* vec);//返回当前向量所能容纳的最大元素个数

void  Vector_sort( vector* vec,int (*Sort)(void *x,void *y));//排序
void Vector_swap( vector*vec1,  vector*vec2);//交换两个同类型向量的数据
//开辟一个动态数组
vector* NewVector(const char* arr, ...);

vector.c(函数实现)

#include"vector.h"
typedef struct VECTOR
{
	//插入函数
	void(*push_back)(void*);//尾插
	void (*insert_front)(struct VECTOR*, const void* p, const void* x);// 向量中指向元素p前增加一个元素x
	void (*insert_nfront)(struct VECTOR*, const void* p, const int n, const void* x);// 向量中指向元素p前增加n个相同的元素x
	void (*insert)(struct VECTOR*, const void* p, const void* p1, const void* p2);// 向量中指向元素p前插入另一个相同类型向量的指针[p1,p2)间的数据
	//删除函数
	void (*pop_back)(struct VECTOR*);//尾删
	void (*erase_p)(struct VECTOR*, const void*, const void*);//删除指针区间内的数据
	void (*erase_int)(struct VECTOR*, const int, const int);//删除区间内的数据
	void (*clear) (struct VECTOR*);//清空vector的队列，释放内存
	//遍历函数
	void* (*at)(const struct VECTOR*, int);// 返回第0-n个元素的指针
	void* (*front)(const struct VECTOR*);// 返回向量头指针，指向第一个元素
	void* (*back)(const struct VECTOR*);//返回向量尾指针，指向向量最后一个元素
	void* (*find)(const struct VECTOR* vec, const void* val, bool(*fi)(const void* val1, const void* val2));//查找数据，返回找到的指针，没有返回NULL
	//判断函数
	bool (*empty)(const struct VECTOR*);// 检测vector内是否为空，空为真 O(1)
	//大小函数
	int (*size)(const struct VECTOR*);//返回vector内元素的个数 O(1)
	int (*capacity)(const struct VECTOR*); //返回当前向量所能容纳的最大元素值
	//其他函数
	void (*sort)(struct VECTOR*, int (*Sort)(void*, void*));//排序
	void (*swap)(struct VECTOR*, struct VECTOR*);//交换两个同类型向量的数据
	void* _date;//指向自定义数组类型
	int  _current;//当前元素个数
	int _size;//元素最大个数
	int _type;//类型占用字节数
}VECTOR;

static void swap(void* x, void* y,const int n)//交换任意数据类型的函数
{
	void* p = malloc(n);
	if (p == NULL)
	{
		perror("交换函数创建p临时空间失败");
		exit(-1);
	}
	memcpy(p, x, n);
	memcpy(x, y, n);
	memcpy(y, p, n);
	free(p);
}
//检测是否需要扩容
static void Capacity(VECTOR* vec)
{
	if (vec->_size ==0)
	{
		vec->_date = malloc(vec->_type * VECTORNUM);
		if (vec->_date == NULL)
		{
			perror("初始化vector失败");
			exit(-1);
		}
		else
		{
			vec->_size = VECTORNUM;
		}
	}
	else if (vec->_size == vec->_current)//空间已满需要扩容
	{
		void* _date = realloc(vec->_date, vec->_size * vec->_type * 2);
		if (_date == NULL)
		{
			perror("扩容失败vector");
			exit(-1);
		}
		else
		{
			vec->_date = _date;
			vec->_size *= 2;
		}
	}
}
void Vector_clear(struct VECTOR* vec)//清空vector的数组，释放内存
{
	if (vec->_date != NULL)
	{
		free(vec->_date);
		vec->_date = NULL;
		vec->_current = 0;
		vec->_size = 0;
	}
}
void Vector_Push_Back(VECTOR* vec,void* x)// 向量尾部增加一个元素X
{
	Capacity(vec);
	char* str1 = (char*)vec->_date + vec->_type * vec->_current;
	memcpy(str1,x, vec->_type);
	vec->_current++;
}
void Vector_insert_front(VECTOR* vec,const void* p, const void* x)// 向量中指向元素p前增加一个元素x
{
	Capacity(vec);
	if (p >= vec->front(vec) && p <= vec->back(vec))
	{
		int size = (char*)vec->back(vec) - p + vec->_type;
		void* ptr = malloc(size);
		memcpy(ptr, p, size);
		memcpy(p, x, vec->_type);
		memcpy((char*)p + vec->_type, ptr, size);
		vec->_current++;
		free(ptr);
	}
}
void Vector_insert_nfront(VECTOR* vec, const void* p, const int n, const void* x)// 向量中指向元素p前增加n个相同的元素x
{
	if (p >= vec->front(vec) && p <= vec->back(vec))
	{
		Capacity(vec);
		int size = (char*)vec->back(vec) - p + vec->_type;
		void* ptr = malloc(size);
		memcpy(ptr, p, size);
		int sizen= ((char*)p-vec->front(vec))/vec->_type;
		for (size_t i = 0; i < n; i++)
		{
			Capacity(vec);
			memcpy((char*)vec->at(vec,sizen), x, vec->_type);
			sizen++;
			vec->_current++;
		}
		memcpy((char*)vec->at(vec, sizen), ptr, size);
		free(ptr);
	}
}
void Vector_insert(VECTOR* vec, const void* p, const void* p1, const void* p2)// 向量中指向元素p前插入另一个相同类型向量的指针[p1,p2)间的数据
{
	if (p >= vec->front(vec) && p <= vec->back(vec))
	{
		Capacity(vec);
		int size = (char*)vec->back(vec) - p + vec->_type;
		void* ptr = malloc(size);
		memcpy(ptr, p, size);
		int sizen = ((char*)p - vec->front(vec)) / vec->_type;
		int push_n = ((char*)p2 - (char*)p1) / vec->_type+1;
		for (size_t i = 0; i < push_n; i++)
		{
			Capacity(vec);
			memcpy((char*)vec->at(vec, sizen),(char*)p1+i*vec->_type, vec->_type);
			sizen++;
			vec->_current++;
		}
		memcpy((char*)vec->at(vec, sizen), ptr, size);
		free(ptr);
	}
}
void Vector_pop_back(struct VECTOR* vec)//删除向量中最后一个元素
{
	vec->_current--;
}
void Vector_erase_p(struct VECTOR* vec, const void* p1, const void* p2)//删除指针区间内的数据
{
	if (p1<=p2&&vec->front(vec)<=p1&&p2<=vec->back(vec))
	{
		memcpy(p1, (char*)p2 + vec->_type,(int)((char*)vec->back(vec)-(char*)p2));
		vec->_current -= (((int)((char*)p2 - (char*)p1))/vec->_type+1);
	}
}
void Vector_erase_int(struct VECTOR* vec, const int left, const int right)//删除区间内的数据
{
	if (left <= right && left >= 0 && right < vec->_current)
	{
		memcpy(vec->at(vec,left),vec->at(vec,right+1),(vec->_current-1-right)*vec->_type);
		vec->_current -= (right - left + 1);
	}
}
void* Vector_at(const struct VECTOR* vec, int i)// 返回元素的指针
{
	if (i+1 > vec->_current)
	{
		return NULL;
	}
    return (void*)((char*)vec->_date + vec->_type * i);
}
void* Vector_front(const struct VECTOR* vec)//返回向量头指针，指向第一个元素
{
	return vec->_date;
}
void* Vector_back(const struct VECTOR* vec)//返回向量尾指针，指向向量最后一个元素
{
	char* _date = (char*)vec->_date + vec->_type * (vec->_current-1);
	return _date;
}

bool Vector_empty(const struct VECTOR* vec)//检测vector内是否为空，空为真 O(1)
{
	return !vec->_current;
}
int Vector_size(const struct VECTOR* vec)//返回vector内元素的个数 O(1)
{
	return vec->_current;
}
int  Vector_capacity(const struct VECTOR* vec)//返回当前向量所能容纳的最大元素值
{
	return vec->_size;
}

void  Vector_sort(struct VECTOR* vec, int (*Sort)(void* x, void* y))//排序
{
	qsort(vec->_date, vec->_current, vec->_type, Sort);
}
void Vector_swap(struct VECTOR* vec1, struct VECTOR* vec2)//交换两个同类型向量的数据
{
	swap(&vec1->_date, &vec2->_date, sizeof(void*));
	swap(&vec1->_current, &vec2->_current, sizeof(int));
	swap(&vec1->_size, &vec2->_size, sizeof(int));
}
void* Vector_find(const struct VECTOR* vec, const void* val,bool(*fi)(const void* val1,const void* val2))//查找数据，返回找到的指针，没有返回NULL
{
	for (int i = 0; i < vec->size(vec); i++)
	{
		//if (memcmp(vec->at(vec, i), val, vec->_type) == 0)
		if(fi(vec->at(vec, i),val))
		{
			return vec->at(vec, i);
		}
	}
	return NULL;
}
//初始化函数
//void VectorInitial(VECTOR* vec, int n)
vector* NewVector (const char* arr, ...)
{
	VECTOR * vec = malloc(sizeof(VECTOR));
	char buf[20];
	strcpy(buf, arr);
	size_t len = strlen(buf);
	//printf("去空格前：%s
", buf);
	//去掉字符串空格
	for (size_t i = 0; i < len; i++)
	{
		if (buf[len - 1 - i] == )
		{
			for (size_t j = 0; j < i + 1; j++)
			{
				buf[len - 1 - i + j] = buf[len - i + j];
			}
		}
	}
	//printf("去空格后：%s  长度：%d
", buf,strlen(buf));
	/*if (strcmp(buf, "char") == 0)
	{
		vec->_type= sizeof(char);

	}
	else*/
	{
		va_list args;//接收可变参数，
		va_start(args, arr);
		size_t n = va_arg(args, size_t);//依次访问参数，需指定按照什么类型读取数据  
		if (n <= 0 || n > 1000)
		{
			perror("您的类型本程序无内置请输入类型的字符数量，将以void指针形式返回，请强转后解引用使用（上限1000字节）
");
			exit(-1);
		}
		va_end(args);//参数使用结束  
		vec->_type = n;
	}
	vec->clear = Vector_clear;//清空vector的队列，释放内存
	vec->push_back = Vector_Push_Back;//尾插
	vec->insert_front = Vector_insert_front;// 向量中指向元素p前增加一个元素x
	vec->insert_nfront = Vector_insert_nfront;// 向量中指向元素p前增加n个相同的元素x
	vec->insert = Vector_insert;// 向量中指向元素p前插入另一个相同类型向量的指针[p1,p2)间的数据
	vec->pop_back = Vector_pop_back;//尾删
	vec->erase_p = Vector_erase_p;//删除指针区间内的数据
	vec->erase_int = Vector_erase_int;//删除区间内的数据
	vec->at = Vector_at;//返回指定位置的指针
	vec->front = Vector_front;//返回向量头指针，指向第一个元素
	vec->back = Vector_back;//返回向量尾指针，指向向量最后一个元素
	vec->find = Vector_find;//查找数据，返回找到的指针，没有返回NULL
	vec->empty = Vector_empty;//检测vector内是否为空，空为真 O(1)
	vec->size = Vector_size;//返回vector内元素的个数 O(1)
	vec->capacity = Vector_capacity;//返回当前向量所能容纳的最大元素值
	vec->sort = Vector_sort;//排序
	vec->swap = Vector_swap;//交换两个同类型向量的数据
	//vec->_type = n;
	vec->_current = 0;
	vec->_size = 0;
	vec->_date = NULL;
	return vec;
}

test.c(测试代码)

#include"vector.h"
#include<time.h>
int mysort(const void* a, const void* b)
{
	return (*(int*)a - *(int*)b);//升序
	//return (*(int*)b - *(int*)a);//降序
}
void test1()
{
	//vector vec;//创建容器
	//VectorInitial(&vec, sizeof(int));//初始化容器
	vector* vec = NewVector("int", sizeof(int));
	int num = 10;
	vec->push_back(vec, &num);//尾插
	//printf("%d
", *(int*)vec->at(vec, 0));

	num = 21;
	vec->push_back(vec, &num);//尾插
	//printf("%d
", *(int*)vec->at(vec, 1));

	//vec->pop_back(vec);//尾删除
	//printf("%d
", (int*)vec->at(vec, 1) == NULL ? -1 : *(int*)vec->at(vec, 1));

	num = 123;
	vec->push_back(vec, &num);//尾插
	num = 245;
	vec->push_back(vec, &num);//尾插
	num = 16;
	vec->push_back(vec, &num);//尾插
	num = 55;
	vec->push_back(vec, &num);//尾插
	printf("头部元素:%d
", *(int*)vec->front(vec));//获取头部元素
	printf("尾部元素:%d
", *(int*)vec->back(vec));//获取尾部元素
	vec->sort(vec, mysort);//排序函数
	printf("下面为元素遍历
");
	for (size_t i = 0; i < vec->size(vec); i++)
	{
		printf("%d
", *(int*)vec->at(vec, i));
	}
	printf("vector空间大小为%d，已使用元素%d个", vec->capacity(vec), vec->size(vec));
	vec->clear(vec);
}

int main()
{
	test1();
	return 0;
}