Шаблон функции сортировки массива структур по разным типам полей

struct note
{
    char fam[20];   // фамилия
    char name[20];  // имя
    char phone[10]; // телефон
    int  data_r[3]; // дата рождения, массив из трех чисел: год, месяц, день
    int  oklad;     // оклад
};
 
// шаблон сравнения элементов структуры
template <class item> 
void compare_swap (item &a, item &b)
{
    if (b < a) 
        swap(a, b);
}
 
// шаблон обмена элементов структуры
template <class item>
void swap(item&a, item&b)
{
    item temp;
    temp = a;
    a = b;
    b = temp;
}
 
// шаблон сортировки массива структур методом выбора
// вот тут моя наглая попытка передачи сортируемого поля структуры в параметр [B]key[/B], увы НЕ катит (
// а так хотелось передавать сюда по очереди нужные поля: fam, oklad, data_r[3] !
//
template <class T, class item> 
void selection_sort(T a[], [B]item key[/B], int left, int right)
{ 
    for (int i = left+1; i <= right; i++)
        for (int j = i; j > left; j--) 
            compare_swap(a[j-1][B][COLOR="Red"]->key[/COLOR][/B], a[j][B][COLOR="Red"]->.key[/COLOR][/B]);
}

int compare_name(note a[], char* name);
int compare_oklad(note a[], int oklad);
int compare_date(note a[], int data_r[3]);

compare_swap(a[j-1], a[j], compare_name);

// шаблон сравнения элементов структуры
template <class item> 
void compare_swap (item &a, item &b, int *(pf_compare)(note a[], ?..))
{
    if (pf_compare(a, b) < 0) 
        swap(a, b);
}
 
// шаблон обмена элементов структуры
template <class item>
void swap(item&a, item&b)
{
    item temp;
    temp = a;
    a = b;
    b = temp;
}

int compare_name(note & a, note & b);  //реализация сравнения по имени
int compare_oklad(note & a, note & b); //реализация сравнения по окладу
int compare_date(note & a, note & b);  //реализация сравнения по дате
 
 
// шаблон сравнения элементов структуры
template <class item>
void compare_swap(item &a, item &b, int (*pf_compare)(item & a, item & b))
{
    if (pf_compare(a, b) < 0)
        swap(a, b);
}
 
//.....
 
compare_swap(a, b, &compare_name);

// -----------------------------------------------------------------------------
// Лабораторная работа №5
// Задание 1
//
//Считайте все записи из файла "1.dat" (Лаб.раб.2. Задание 3). 
//Для чтения каждой отдельной записи осуществите динамический захват памяти. 
//Предполагается, что к-во записей в файле заранее неизвестно.
//
//Выполните сортировку записей по различным ключам:
// по фамилии (по возрастанию); 
// по дате рождения (по возрастанию); 
// по окладу (по убыванию). 
//
//Для каждого ключа используйте различные алгоритмы сортировки: 
// сортировка выбором,  
// сортировка вставками,  
// сортировка Шелла,  
// быстрая сортировка.  
//
//Всего сортировка будет выполнена 12 раз, каждый раз сортируется массив в первоначальном состоянии.
//Для каждого случая подсчитайте к-во сравнений и перестановок.
//Оцените скорость, естественность и устойчивость каждого алгоритма.
//Оптимальную организацию функций продумайте самостоятельно.
//
// Вариант 1.
// студента группы 107213 Абрамчука Антона Алексеевича
// -----------------------------------------------------------------------------
 
#include <iostream>
#include <locale>
#include <fstream>
#include <string.h> // для strcmp()
#include <iomanip>  // для setw
 
//using namespace std;
 
// Объявляем структуру note из Лабораторной работы №2
struct note
{
    char first_name[20]; // фамилия
    char name[20];       // имя
    char phone[10];      // телефон
    int  birth_date[3];  // дата рождения, массив из трех чисел: год, месяц, день
    int  oklad;          // оклад
};
 
// Прототип шаблона функции вывода всего массива структур
template <class T> // или typename Т
void print(T arr[], int size, char const * message);
 
// Прототип шаблона функции вывода одной структуры из массива структур 
template <class T>
void print_record(T &record);
 
 
// Прототипы функций сравнения по конкретным полям структуры
int compare_name(note & a, note & b);  // реализация сравнения по имени
int compare_oklad(note & a, note & b); // реализация сравнения по окладу
int compare_date(note & a, note & b);  // реализация сравнения по дате
 
// Прототип шаблона функции обмена двух элементов
template <class item>
void swap(item &a, item &b);
 
// Прототип шаблона сравнения и обмена элементов структуры
template <class item>
void compare_swap(item &a, item &b, int(*pf_compare)(item &a, item &b));
 
// Прототип шаблона функции сортировки выбором
template <class T>
void selection_sort(T *a[], int left, int right, int(*pfun_compare)(T &a, T &b));
 
// Инициализация массива указателей, сброс в первоначальное состояние
// для последующей его сортировки другими видом: выбор, вставка, Шелла, быстрая
void init_array(note **pa_student, note *a_student, int kol_student);
 
 
//------------------------------------------------------------------------------
 
int main(int argc, char *argv[])
{
    // русификация
    setlocale(LC_CTYPE, "Russian");
    // ----------------------------
 
 
    note *a_student;                     // указатель на массив студентов
    int  kol_student;                    // количество студентов в файле
    char filename[] = "1.dat";           // имя файла данных
 
    std::fstream file_in;                                  // объявляем входной файл
    file_in.open(filename, std::ios::in | std::ios::binary);    // открываем файл для чтения из него
    //if (!file_in.is_open())                           // если файл не удалось открыть
    if (!file_in)                           // если файл не удалось открыть
    {
        std::cout << "Не могу открыть файл " << filename;  // сообщаем об ошибке
        return 1;                                     // и завершаем программу с ошибкой
    }
 
    // вычислим количество студентов в файле
    file_in.seekg(0, std::ios::end);           // передвинем указатель в конец файла
    int end_pos = file_in.tellg();        // получаем размер файла в байтах = позиции указателя в конце
    kol_student = end_pos / sizeof(note); // количество записей = размер файла / размер записи
    file_in.seekg(0, std::ios::beg);           // передвинем опять указатель в начало файла
 
    a_student = new note[kol_student];    // выделяем память для num_records студентов
 
    // можно читать данные из файла по одному студенту за раз
    // цикл пока не конец файла
    // функция file_in.eof() возвращает истину если достигнут конец
    //for (int i = 0; i < num_records && !file_in.eof(); i++)
    //  file_in.read((char *)a_student, sizeof(note));
 
    // но лучше прочитать все сразу!
    file_in.read((char*)a_student, sizeof(note)* kol_student);
 
    file_in.close();  // закрываем файл
 
    // создаем динамический вспомогательный массив по количеству студентов
    note ** pa_student = new note*[kol_student];
 
    char const * message; // для передачи сообщений в функции вывода
    // выводим полученный список студентов
    message = "Исходный Список студентов";
    print(a_student, kol_student, message);
 
    system("pause"); // пауза перед очисткой экрана
    system("cls");   // очистка экрана
 
    // заполняем вспомогательный массив указателями на студентов
    init_array(pa_student, a_student, kol_student);
    //for (int i = 0; i < kol_student; i++)
    //  pa_student[i] = &a_student[i];
 
    //----------------------------------------------------------------------------------
    // По Фамилии
    message = "Список студентов отсортированный по фамилии";
    selection_sort(pa_student, 0, kol_student, compare_name);
    print(*pa_student, kol_student, message);
 
    system("pause"); // пауза перед очисткой экрана
    //system("cls");   // очистка экрана
 
    // По Окладу
    // перезаполняем массив указателей на студентов
    init_array(pa_student, a_student, kol_student);
    //for (int i = 0; i < kol_student; i++)
    //  pa_student[i] = &a_student[i];
 
    message = "Список студентов отсортированный по окладу";
    selection_sort(pa_student, 0, kol_student, compare_oklad);
    print(*pa_student, kol_student, message);
 
    system("pause"); // пауза перед очисткой экрана
    //system("cls");   // очистка экрана
 
    // По Дате рождения
    // перезаполняем массив указателей на студентов
    init_array(pa_student, a_student, kol_student);
    //for (int i = 0; i < kol_student; i++)
    //  pa_student[i] = a_student[i];
 
    message = "Список студентов отсортированный по дате рождения";
    selection_sort(pa_student, 0, kol_student, compare_date);
    print(*pa_student, kol_student, message);
 
    //system("pause"); // пауза перед очисткой экрана
    ////system("cls");   // очистка экрана
 
    //----------------------------------------------------------------------------------
 
    // освобождаем выделенную память перед выходом
    //for (int i = 0; i < num_records; i++)
    //  delete [] a_student[i];
    delete[] a_student;
    delete[] pa_student;
    a_student  = 0;
    pa_student = 0;
 
 
    // ----------------------------
    // пауза перед выходом
    std::cout << std::endl << std::endl;
    system("pause");
 
    return 0;
 
} // конец main
 
 
void init_array(note **pa_student, note *a_student, int kol_student)
{
    for (int i = 0; i < kol_student; i++)
        pa_student[i] = &a_student[i];
}
 
// -------------------------------------------------------------------
// Шаблон функции вывода списка студентов
//
template <class T>
void print(T arr[], int arr_size, char const * message)
{
    std::cout << std::endl;
    std::cout << std::setw(40) << message << std::endl;
    std::cout << "---------------------------------------------------------------------\n";
    std::cout << "Фамилия           Имя         Телефон  Дата рожд.  Оклад   Ссылка  \n";
    std::cout << "---------------------------------------------------------------------\n";
 
    for (int i = 0; i < arr_size; i++) // цикл по количеству студентов
        print_record(arr[i], i);       // вывод одного студента
 
    std::cout << std::endl;
}
 
// -------------------------------------------------------------------
// Шаблон функции вывода одного студента
//
template <class T>
void print_record(T &student, int i)
{
    std::cout << std::setw(2) << i + 1 << ") "
        << std::setfill(' ') << std::left
        << std::setw(13)
        << student.first_name << " "
        << std::setw(10)
        << student.name << " "
        << std::right
        << std::setw(8) << student.phone << "  "
        << std::setfill('0') << std::setw(2) << student.birth_date[2] << "/"
        << std::setfill('0') << std::setw(2) << student.birth_date[1] << "/"
        << student.birth_date[0] << " "
        << std::setfill(' ')
        << std::setw(4) << student.oklad << " руб "
        << &student // адрес указателя
        << std::endl;
}
 
 
//------------------------------------------------------------------------------
// Сортировка массива структур методом выбора
//
//  Сначала отыскивается наименьший элемент массива, 
//  затем он меняется местами с элементом, стоящим первым в сортируемом    массиве.
//  Далее, находится второй наименьший элемент и меняется местами с элементом, стоящим вторым в исходном массиве. 
//  Этот процесс продолжается до тех пор, пока весь массив не будет отсортирован.
//
// Параметры:
//  1) T *a[]    - указатель на массив структур
//  2) int left  - левый индекс в массиве, с него начинаем поиск
//  3) int right - правый индекс в массиве, до которого продолжаем поиск
//  4) int(*pf_compare)(T &a, T &b) - указатель на функцию сравнения двух структур по конкретному полю
//
template <class T>
void selection_sort(T *a[], int left, int right, int(*pf_compare)(T &a, T &b))
{
    // внешний цикл начинаем со следующего индекса от левой границы (со второго)
    for (int i = left + 1; i < right; i++)
    {
        // во внутреннем цикле сравниваем текущий элемент с элементами слева от текущего
        for (int j = i; j > left; j--)
        {
            // сравниваем элементы
            compare_swap(*(a[j - 1]), *(a[j]), pf_compare);
        }
    }
}
 
// Сравнение и, если нужно обмен элементов структуры
// Параметры:
//  1) item &a  - ссылка на 1-ю структуру
//  2) item &b  - ссылка на 2-ю структуру
//  3) int(*pf_compare)(T &a, T &b) - указатель на функцию сравнения двух структур по конкретному полю
//
template <class item>
void compare_swap(item &a, item &b, int(*pf_compare)(item &a, item &b))
{
    // сравниваем две структуры
    if (pf_compare(a, b) > 0)
    {
        // если результат сравнения положителен, меняем в массиве элементы местами
        swap(a, b);
    }
}
 
 
// обмен двух элементов
// Параметры:
//  1) item &a  - ссылка на 1-ю структуру
//  2) item &b  - ссылка на 2-ю структуру
//
template <class item>
void swap(item &a, item &b)
{
    item temp;
    temp = a;
    a = b;
    b = temp;
}
 
 
// сравнение по имени
int compare_name(note & a, note & b)
{
    //int i = 0;
    //if (a.first_name[0] < b.first_name[0])
    //  i = -1;
    //else if (a.first_name[0] > b.first_name[0])
    //  i = 1;
 
    //return i;
 
    return strcmp(a.first_name, b.first_name);
}
 
// сравнение по окладу
int compare_oklad(note & a, note & b)
{
    int i = 0;
    if (a.oklad < b.oklad)
        i = -1;
    else if (a.oklad > b.oklad)
        i = 1;
 
    return i;
}
 
// сравнение по дате
int compare_date(note & a, note & b)
{
    int i = 0;
    //if (a.birth_date[0] < b.birth_date[0])
    //  i = -1;
    //else if (a.birth_date[0] > b.birth_date[0])
    //  i = 1;
 
    //return i;
 
    //сравниваем год
    if (a.birth_date[0] < b.birth_date[0]) 
        i = -1;
    else if (a.birth_date[0] > b.birth_date[0]) 
        i = 1;
    else if (a.birth_date[0] == b.birth_date[0])
    {
        //сравниваем месяц
        if (a.birth_date[1] < b.birth_date[1]) 
            i = -1;
        else if (a.birth_date[1] > b.birth_date[1]) 
            i = 1;
        else if (a.birth_date[1] == b.birth_date[1])
        {
            // сравниваем день
            if (a.birth_date[2] < b.birth_date[2])
                i = -1;
            else i = 1;
        }
    }
    return i;
}