利用C实现泛型（generics）效果---原地洗牌，快速排序

用一个函数实现一个算法，能够应用在不同的数据类型（int，double，字符数组）上，这在C++，python等高级语言中是很常见的。

灵活地利用C中的void指针，内存操作，函数指针也可以实现类似的效果。

用void指针指向特定元素的地址，如果传入元素占内存大小（如sizeof(int)，sizeof(double)），可以用memcpy实现赋值操作。

如果实现了用于元素间比较或四则运算的函数并将其指针传入（如int (*cmp)(void*，void*)），则能在算法中不考虑数据类型实现更多功能。

比如下面一段函数，实现了原地洗牌，快速排序两种算法：

#include <stdlib.h>
#include <string.h>
#include <time.h>

//omit ptr check when malloc and realloc 

void swap(void* ap, void* bp, int elem_size) {
	void* buffer = malloc(elem_size);
	memcpy(buffer, ap, elem_size);
	memcpy(ap, bp, elem_size);
	memcpy(bp, buffer, elem_size);
	free(buffer);
}

void randomize_in_place(void* arr, int n, int elem_size) {
	int rand_place;
	srand((unsigned int)time(NULL));
	for(int i=0; i<n; i++) {
		rand_place = rand() % (n-i) + i;
		swap((char*)arr+i*elem_size, (char*)arr+rand_place*elem_size, elem_size);
	}
}

int int_cmp(const void* ap, const void* bp) {
	return *(int*)ap - *(int*)bp;
}

int double_cmp(const void* ap, const void* bp) {
	if(*(double*)ap - *(double*)bp < 0)
		return -1;
	else if(*(double*)ap - *(double*)bp == 0)
		return 0;
	else
		return 1;
}

int charptr_cmp(const void* ap, const void* bp) {
	return strcmp(*(char**)ap, *(char**)bp);
}

int randomized_partition(void* arr, int p, int r, int elem_size, int (*compar)(const void*, const void*)) {
	srand((unsigned int)time(NULL));
	int rand_elem_index = rand() % (r-p+1) + p;
	char* rand_elem_ptr = (char*)arr + rand_elem_index * elem_size;
	char* pivot_ptr = (char*)arr + r * elem_size;
	swap(rand_elem_ptr, pivot_ptr, elem_size);
	// start to partition, arr[r]=pivot
	// p<=k<=i arr[k]<=pivot, i+1<=k<=j-1 arr[k]>pivot 
	int i = p - 1;
	char* ith_elem_ptr = NULL;
	char* jth_elem_ptr = NULL;
	for(int j=p; j<r; j++) {
		jth_elem_ptr = (char*)arr + j * elem_size;
		if(compar(jth_elem_ptr, pivot_ptr) <= 0) {
			i = i + 1;
			ith_elem_ptr = (char*)arr + i * elem_size;
			swap(ith_elem_ptr, jth_elem_ptr, elem_size);
		}
	}
	swap((char*)arr+(i+1)*elem_size, pivot_ptr, elem_size);
	return i+1;
}

void recursive_qsort(void* arr, int p, int r, int elem_size, int (*compar)(const void*, const void*)) {
	if(p < r) {
		int q = randomized_partition(arr, p, r, elem_size, compar);
		recursive_qsort(arr, p, q-1, elem_size, compar);
		recursive_qsort(arr, q+1, r, elem_size, compar);
	}
}

void generic_qsort(void* arr, int n, int elem_size, int (*compar)(const void*, const void*)) {
	recursive_qsort(arr, 0, n-1, elem_size, compar);
}

int main(int argc, char** argv) {
	int int_array[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
	randomize_in_place(int_array, 10, sizeof(int));  //test
	generic_qsort(int_array, 10, sizeof(int), int_cmp);  //test
	double double_array[6] = {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
	randomize_in_place(double_array, 6, sizeof(double));  //test
	generic_qsort(double_array, 6, sizeof(double), double_cmp);  //test
	char* charptr_array[6] = {"generics", "hccc", "spring", "summer", "autumn", "winter"};
	randomize_in_place(charptr_array, 6, sizeof(char*));  //test
	generic_qsort(charptr_array, 6, sizeof(char*), charptr_cmp);  //test
}

在《C++编程思想》那本书中的，“一个袖珍的C库”那一小节，利用类似的思想实现了一个stash，不过那里使用的是字符拷贝，而且只考虑了元素存取，没有更复杂的操作。