Vector Implementation for C

main.c

#include <stdio.h>
#include "Vector.h"

bool cmp(const void* a, const void* b) {
	return *(int*) a - *(int*) b;
}

int main(int argc, char** argv) {
	vector* vec = tg_vector_new(sizeof(int));
	tg_vector_add(vec, 1);
	tg_vector_add(vec, 5);

	for (uint i = 0; i < vec->length; i++) {
		printf("%d\n", tg_vector_get(vec, i));
	}

	tg_vector_remove(vec, 0);
	printf("--------------\n");

	for (uint i = 0; i < vec->length; i++) {
		printf("%d\n", tg_vector_get(vec, i));
	}

	tg_vector_insert(vec, 0, 6);
	tg_vector_insert(vec, 1, 77);
	printf("--------------\n");

	for (uint i = 0; i < vec->length; i++) {
		printf("%d\n", tg_vector_get(vec, i));
	}

	tg_vector_qsort(vec, cmp);
	printf("--------------\n");

	for (iterator it = tg_vector_begin(vec); it < tg_vector_end(vec); ++it) {
		printf("%d\n", *it);
	}

	tg_vector_free(&vec);

	getchar();
	return 0;
}

Types.h

#ifndef TYPES_H
#define TYPES_H

#include <stdint.h>

typedef uint32_t	uint;

typedef uint8_t		bool;
#define true 1
#define false 0

#define fptr(ret, name, ...) ret (*name)(__VA_ARGS__)

#endif

Vector.c

#include "Vector.h"

#include <assert.h>
#include <stdlib.h>
#include <memory.h>

vector* tg_vector_new(uint dataBlockSize) {
	assert(dataBlockSize > 0);

	vector* vec = (vector*) malloc(sizeof(vector));
	vec->dataBlockSize = dataBlockSize;
	vec->length = 0;
	vec->capacity = VECTOR_INITIAL_CAPACITY;
	vec->data = malloc(vec->capacity * dataBlockSize);

	memset(vec->data, NULL, vec->capacity * dataBlockSize);

	return vec;
}

void tg_vector_free(vector **vec) {
	free((*vec)->data);
	free(*vec);
	*vec = NULL;
}

void tg_vector_add(vector *vec, void *data) {
	if (vec->length > vec->capacity) {
		vec->capacity *= 2;
		vec->data = realloc(vec->data, vec->capacity * vec->dataBlockSize);
	}

	vec->data[vec->length++] = data;
}

void tg_vector_insert(vector *vec, uint index, void *data) {
	assert(index >= 0);
	if (vec->length > vec->capacity) {
		vec->capacity *= 2;
		vec->data = realloc(vec->data, vec->capacity * vec->dataBlockSize);
	}

	memmove(
		vec->data + index + 1,
		vec->data + index,
		(vec->length - index + 1) * vec->dataBlockSize
	);
	vec->data[index] = data;
	vec->length++;
}

void* tg_vector_get(vector *vec, uint index) {
	assert(index >= 0 && index <= vec->length - 1);
	return vec->data[index];
}

void tg_vector_set(vector *vec, uint index, void *data) {
	assert(index >= 0 && index <= vec->length - 1);
	vec->data[index] = data;
}

void tg_vector_remove(vector *vec, uint index) {
	assert(index >= 0 && index <= vec->length - 1);
	if (index == vec->length - 1) {
		vec->length--;
	} else if (index < vec->length - 1) {
		memmove(
			vec->data + index,
			vec->data + (index + 1),
			(vec->length - index - 1) * vec->dataBlockSize
		);
		vec->length--;
	}
}

bool tg_vector_is_empty(vector *vec) {
	return vec->length == 0;
}

void* tg_vector_front(vector *vec) {
	return tg_vector_get(vec, 0);
}

void* tg_vector_back(vector *vec) {
	return tg_vector_get(vec, vec->length - 1);
}

void tg_vector_pop_back(vector *vec) {
	tg_vector_remove(vec, vec->length - 1);
}

iterator tg_vector_begin(vector *vec) {
	return &vec->data[0];
}

iterator tg_vector_end(vector *vec) {
	return &vec->data[vec->length];
}

void tg_vector_qsort(vector *vec, fptr(int, cmpfunc, const void *, const void *)) {
	qsort(vec->data, vec->length, vec->dataBlockSize, cmpfunc);
}

Vector.h

#ifndef VECTOR_H
#define VECTOR_H

#include "Types.h"

#define VECTOR_INITIAL_CAPACITY 100

typedef void** iterator;

typedef struct tg_vector {
	uint length, capacity;
	uint dataBlockSize;
	void** data;
} vector;

vector* tg_vector_new(uint);
void tg_vector_free(vector**);

void tg_vector_add(vector*, void*);
void tg_vector_insert(vector*, uint, void*);
void* tg_vector_get(vector*, uint);
void tg_vector_set(vector*, uint, void*);
void tg_vector_remove(vector*, uint);
bool tg_vector_is_empty(vector*);

void* tg_vector_front(vector*);
void* tg_vector_back(vector*);
void tg_vector_pop_back(vector*);

iterator tg_vector_begin(vector*);
iterator tg_vector_end(vector*);

void tg_vector_qsort(vector*, fptr(int, cmpfunc, const void*, const void*));

#endif

My brain is malfunctioning right now, Jesus Christ, I need to start doing C again...