基于C++类模板编写一个排序类，至少实现三种排序算法，并用这个排序类对学生数组进行排序，学生类包含姓名、成绩等属性及对应的读写方法、运算符

以下是一个基于C++类模板的排序类，实现了三种排序算法（冒泡排序、插入排序、选择排序）：

#include <iostream>
#include <vector>

template <class T>
class Sorter {
public:
    static void bubbleSort(std::vector<T>& arr) {
        int n = arr.size();
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    std::swap(arr[j], arr[j + 1]);
                }
            }
        }
    }

    static void insertionSort(std::vector<T>& arr) {
        int n = arr.size();
        for (int i = 1; i < n; i++) {
            T key = arr[i];
            int j = i - 1;
            while (j >= 0 && arr[j] > key) {
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j + 1] = key;
        }
    }

    static void selectionSort(std::vector<T>& arr) {
        int n = arr.size();
        for (int i = 0; i < n - 1; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (arr[j] < arr[minIdx]) {
                    minIdx = j;
                }
            }
            std::swap(arr[i], arr[minIdx]);
        }
    }
};

class Student {
public:
    Student(std::string name, int score) : name_(name), score_(score) {}

    std::string getName() const {
        return name_;
    }

    int getScore() const {
        return score_;
    }

    bool operator>(const Student& other) const {
        return score_ > other.score_;
    }

    bool operator<(const Student& other) const {
        return score_ < other.score_;
    }

private:
    std::string name_;
    int score_;
};

int main() {
    std::vector<Student> students = {
        {"Alice", 85},
        {"Bob", 70},
        {"Charlie", 95},
        {"David", 60},
        {"Eva", 80},
        {"Frank", 75},
        {"Grace", 90},
        {"Henry", 65},
        {"Ivy", 87},
        {"Jack", 82}
    };

    std::cout << "Before sorting:" << std::endl;
    for (const auto& student : students) {
        std::cout << student.getName() << ": " << student.getScore() << std::endl;
    }

    Sorter<Student>::bubbleSort(students);
    // Sorter<Student>::insertionSort(students);
    // Sorter<Student>::selectionSort(students);

    std::cout << "\nAfter sorting:" << std::endl;
    for (const auto& student : students) {
        std::cout << student.getName() << ": " << student.getScore() << std::endl;
    }

    return 0;
}

可以看到，在排序类中，我们实现了三个静态成员函数，分别代表冒泡排序、插入排序和选择排序。这三个排序算法的实现可以参考相关资料，这里不再赘述。

同时，在学生类中，我们实现了 `operator>` 和 `operator<` 运算符，用于比较学生的成绩大小，以便排序算法能够正确排序。

在 `main` 函数中，我们创建了一个学生数组，使用排序类对其进行排序，最终输出排序结果。可以看到，排序类可以适用于任何可比较的类型，并且可以方便地通过调用静态成员函数实现各种排序算法。