C语言下的并归融合接口

其实这是一道面试题，要求将两个有序的长度分别为L1、L2的数组，融合成为一个有序的长度为L1+L2的数组，数组类型不限，需要提供标准接口。
我一想，这个东西简单，用范型呗，在.net下无非就是写个方法，方法原型为：
T[] Merge(T[] left, T[]right, IComparer<T> comparer);
实现也简单，里面的参数check也简单，同样的，在JAVA这种支持范型的语言下，基本上也是类似的东西。
不过问题是，人家让用C写，题目上说的是参照函数库qsort（快速排序）写。我只能说，C语言里的qsort我不但没用过，而且没见过……
好吧，C就C，虽然没见过，至少咱不傻。范型不是没有么？没关系，咱用void*，接口不是也没有么？没关系，咱用函数指针。
老早就把函数指针原型定义好：typedef int (func)(void*,void*);
然后我第一版的函数接口为：void* msort(void* left, int lenght1, void* right, int length2, func* comparer, int typeLength);
具体实现简单，看过归并的同学都知道，我最后再写。
人家一看，你把结果作为返回类型了，不好，C里面基本就是return 个int，告诉你是不是success了。于是我改，第二版如下：
int msort(void* left, int length1, void* right, int length2, void* result, func* comparer, int typeLength);
人家看了说，你这些指针，都能被改变，不安全，完蛋，好吧，加上const。于是第三版就成了这样：
int msort(const void* left, int length1, const void* right, int length2, const func* f, const void* result, int typeLength)；
用JAVA这C#这种语言用久了，早不去想什么是指针了。人们有人说这种语言是快餐式的，也有人说是傻瓜式的，总之它让你不动脑子。
如果入口参数是一个T的数组，什么都免了，我不需要它的长度，因为T[].Length能告诉我，我也不用关心const的问题，因为你随便加它的index，它首地址永远不会变。
感慨发完之后，附上今天我整理的程序代码，我没在C下写过工程，可能会有很多不规范，甚至可能有问题，希望高手指出。

#include <cstdlib>
#include <iostream>

using namespace std;

typedef int (func)(void*,void*);

int compair(void* left, void* right)
{
    int* ptr1 = (int*)left;
    int* ptr2 = (int*)right;
    printf("left is %d, right is %d\n", *ptr1, *ptr2);
    return *ptr1 - *ptr2;
};

int msort(const void* left, int length1, const void* right, int length2, const func* f, const void* result, int typeLength)
{
    if(left == NULL)
        return -1;
    if(length1 <= 0)
        return -2;
    if(right == NULL)
        return -3;
    if(length2 <= 0)
        return -4;
    if(f == NULL)
        return -5;    
    if(result == NULL)
        return -6;
    if(typeLength <= 0)
        return -7;
    int i = 0;
    int j = 0;
    char* ptr1 = (char*)left;
    char* ptr2 = (char*)right;   
    char* rptr = (char*)result; 
    while(i < length1 || j <length2)
    {
        char* ptr = NULL;        
        if(i < length1 && j < length2)
        {             
             if((*f)(ptr1, ptr2)> 0)
             {
                  ptr = ptr2;
                  ptr2 += typeLength;
                  j++;
             }
             else
             {
                  ptr = ptr1;
                  ptr1 += typeLength;
                  i++;
             }
             
        }
        else if(i < length1 && j == length2)
        {
             ptr = ptr1;
             ptr1 += typeLength;
             i++;
        }
        else
        {
             ptr = ptr2;
             ptr2 += typeLength;
             j++;
        }
        for(int k =0; k < typeLength; k++)
        {
            *rptr++ = *ptr++;
        }
    }
    return 0;
};



int main(int argc, char *argv[])
{
    const int left = 4;
    const int right = 6;
    int a[left] = {1, 3, 5, 7};
    int b[right] = {2, 4, 6, 8, 9, 10};
    int typeLength = sizeof(int);
    func* f = &compair;
    int c[left + right] = {0};   
    int* result = c;
    int error = msort(a, 4, b, 6, f, result, typeLength);
    if(error == 0)
    {        
        printf("merge is successful\n");
        for(int i = 0; i< left + right; i++)
        {
             printf("%d\n", *result++);
        }
    }
    else
    {
        printf("An error occurs, error id is %d", error);
    }
    system("PAUSE");
    return EXIT_SUCCESS;
}