Lab Sort Bytes

#include <iostream>
using namespace std;

typedef int (*CompareFunctionType)(void *, void *);
//Теперь переменную это типа можно объявить так:
//CompareFunctionType compare_function_pointer = &Compare;

//В отдельной функции организуйте ввод элементов массива:
void InputIntArray(int input_data[], int length){
    for (int i=0;i<length;i++){
        cin>>input_data[i];
    }
}

void InputCharArray(char my_char_array[], int length){
    for (int i=0;i<length;i++){
        cin>>my_char_array[i];
    }
}

int CompareInt0to9(void *first_pointer, void *second_pointer ) {
    int *first_element_int_pointer = (int *)first_pointer;
    int *second_element_int_pointer = (int *)second_pointer;
    return *first_element_int_pointer - *second_element_int_pointer;
}

int CompareInt9to0(void *first_pointer, void *second_pointer ) {
    int *first_element_int_pointer = (int *)first_pointer;
    int *second_element_int_pointer = (int *)second_pointer;
    return *second_element_int_pointer - *first_element_int_pointer;
}

int CompareCharAtoZ(void *first_pointer, void *second_pointer ) {
    char *first_element_int_pointer = (char *)first_pointer;
    char *second_element_int_pointer = (char *)second_pointer;
    return *first_element_int_pointer - *second_element_int_pointer;
}

int CompareCharZtoA(void *first_pointer, void *second_pointer) {
    char *first_element_int_pointer = (char *)first_pointer;
    char *second_element_int_pointer = (char *)second_pointer;
    return *second_element_int_pointer - *first_element_int_pointer;
}

//В отдельной функции организуйте поиск индекса минимального элемента на подмассиве:
int FindMinimumIndex_old(long input_data[], int first_index, int last_index, CompareFunctionType compare_function_pointer){
    int target=first_index;
    for (int j=first_index;j<last_index;j++){
        if ((*compare_function_pointer)(&input_data[j], &input_data[target])<0) {
            target=j;
        }
    }
    //cout<<target<<endl;
    return target;
}

//В отдельной функции реализуйте обмен элементов массива.
void Swap_old(long &first_element, long &second_element){
    long c=first_element;
    first_element=second_element;
    second_element=c;
}

//В отдельной функции организуйте вывод элементов упорядоченного
//массива:
void OutputIntArray(int input_data[], int length){
    for (int i=0;i<length;i++){
        cout<<input_data[i]<<" ";
    }
    cout<<endl;
}

void OutputCharArray(char input_data[], int length){
    for (int i=0;i<length;i++){
        cout<<input_data[i];
    }
    cout<<endl;
}

///////////////////
void SwapChar(char *first_pointer, char *second_pointer) {
    char temp = *first_pointer;
    *first_pointer = *second_pointer;
    *second_pointer = temp;
    return;
}

void Swap(void *first_pointer, void *second_pointer, int width) {
    for (int byte_number = 0; byte_number < width; ++byte_number) 
        SwapChar((char *)first_pointer + byte_number, (char *)second_pointer + byte_number);
    return;
}

int FindTargetIndex(char *bytevise_array, int width, CompareFunctionType compare_function_pointer, int first_index, int last_index) {
    int target_index = first_index;
    int target_byte_number = target_index * width;
    int current_byte_number = 0;
    for (int element_number = first_index; element_number < last_index; ++element_number) {
        current_byte_number = element_number * width;
        if ((*compare_function_pointer)(&bytevise_array[current_byte_number],&bytevise_array[target_byte_number]) < 0) 
            target_byte_number = current_byte_number;
            //cout<<target_byte_number<<" ";
    }
    //cout<<endl;
    target_index = target_byte_number / width;
    return target_index;
}

//В отдельной функции организуйте сортировку.
void SelectionSort(void *input_data, int width, int length, CompareFunctionType compare_function_pointer){
    char *byte_data=(char *)input_data;
    //OutputIntArray((int *)input_data,length);
    for (int i=0;i<length;i++){
        int target=FindTargetIndex(byte_data,width,compare_function_pointer,i,length);
        //cout<<i<<" "<<target<<" "<<width<<endl;
        Swap(&byte_data[i*width],&byte_data[target*width],width);
        //OutputIntArray((int *)input_data,length);
    }
}

int main() {
    
    int CompareInt0to9(void *first_pointer, void *second_pointer);
    int CompareInt9to0(void *first_pointer, void *second_pointer);
    
    int CompareCharAtoZ(void *first_pointer, void *second_pointer);
    int CompareCharZtoA(void *first_pointer, void *second_pointer);
    
    //Заполнение массивов пропущено...
    //Вызов функции сортировки
    //SelectionSort((void *)my_int_array, kLength, 4, &CompareInt0to9);
   
    
    const int kFunctionsCount = 4;
    //CompareFunctionType compare_function_pointers[kFunctionsCount];
    //compare_function_pointers[0]=CompareInt0to9;
    //compare_function_pointers[1]=CompareInt9to0;
    
    CompareFunctionType compare_function_pointers[kFunctionsCount];
    compare_function_pointers[0]=CompareCharAtoZ;
    compare_function_pointers[1]=CompareCharZtoA;
    compare_function_pointers[2]=CompareInt0to9;
    compare_function_pointers[3]=CompareInt9to0;

    
    int type; cin>>type;
    int n; cin>>n; int m; cin>>m;
    
    char *my_char_array=new char[n];
    int *my_int_array=new int[m];
    
    InputCharArray(my_char_array, n);
    InputIntArray(my_int_array, m);
    
    SelectionSort((void *)my_char_array, sizeof (my_char_array [0]), n, compare_function_pointers[type]);
    SelectionSort((void *)my_int_array, 4, m, compare_function_pointers[type+2]);
    
    OutputCharArray(my_char_array,n);
    OutputIntArray(my_int_array,m);
    return 0;
}