C++模板继承编译错误：排序子类继承Sorter父类时出错

看起来你在实现模板化的排序类继承时踩了几个常见的C++模板语法坑，我来帮你一一梳理解决这些编译错误。

首先，你遇到的expected template-name before '<' token、expected '{' before '<' token、expected UNQUALIFIED-ID before '<' token这些错误，本质都是编译器无法正确解析你继承模板父类的语法，或者不知道Sorter是一个模板类。

第一步：确保父类Sorter是正确的模板类 #

首先你得保证你的Sorter父类是一个模板类，定义应该类似这样：

template <typename T>
class Sorter {
public:
    // 纯虚函数，让子类实现具体排序逻辑
    virtual void sort(T* arr, int size) = 0;
    // 必须加虚析构函数，避免子类对象通过父类指针销毁时内存泄漏
    virtual ~Sorter() = default;
};

如果你的Sorter不是模板类，那你继承时加<T>肯定会报错，这是最常见的原因之一。

第二步：修正子类继承的语法错误 #

你写的class MergeSort : public Sorter <class T>是错误的，问题出在两个地方：

1. 子类本身需要是模板类，必须先声明模板参数列表
2. 继承时不需要重复写class T，直接用已经声明的模板参数T即可

正确的子类写法应该是这样（以归并排序为例）：

// 先声明子类是模板类
template <typename T>
// 继承模板父类Sorter<T>
class MergeSort : public Sorter<T> {
public:
    // 重写父类的纯虚函数，用override关键字确保签名匹配
    void sort(T* arr, int size) override {
        if (size <= 1) return;
        int mid = size / 2;
        T* left = new T[mid];
        T* right = new T[size - mid];
        
        // 拆分数组
        for (int i = 0; i < mid; ++i) left[i] = arr[i];
        for (int i = mid; i < size; ++i) right[i - mid] = arr[i];
        
        // 递归排序左右子数组
        sort(left, mid);
        sort(right, size - mid);
        // 合并结果
        merge(arr, left, mid, right, size - mid);
        
        // 释放临时内存
        delete[] left;
        delete[] right;
    }

private:
    // 归并辅助函数
    void merge(T* arr, T* left, int leftSize, T* right, int rightSize) {
        int i = 0, j = 0, k = 0;
        while (i < leftSize && j < rightSize) {
            arr[k++] = (left[i] <= right[j]) ? left[i++] : right[j++];
        }
        // 处理剩余元素
        while (i < leftSize) arr[k++] = left[i++];
        while (j < rightSize) arr[k++] = right[j++];
    }
};

其他排序子类的示例（比如快速排序） #

为了让你更清楚，再给一个快速排序的子类实现，语法和归并排序一致：

template <typename T>
class QuickSort : public Sorter<T> {
public:
    void sort(T* arr, int size) override {
        quickSort(arr, 0, size - 1);
    }

private:
    void quickSort(T* arr, int low, int high) {
        if (low < high) {
            int pivotIdx = partition(arr, low, high);
            quickSort(arr, low, pivotIdx - 1);
            quickSort(arr, pivotIdx + 1, high);
        }
    }

    int partition(T* arr, int low, int high) {
        T pivot = arr[high];
        int i = low - 1;
        for (int j = low; j < high; ++j) {
            if (arr[j] <= pivot) {
                ++i;
                swap(arr[i], arr[j]);
            }
        }
        swap(arr[i + 1], arr[high]);
        return i + 1;
    }

    void swap(T& a, T& b) {
        T temp = std::move(a);
        a = std::move(b);
        b = std::move(temp);
    }
};

关键注意事项 #

• 子类必须先声明template <typename T>，编译器才知道T是模板参数
• 继承父类时要写Sorter<T>，而不是Sorter <class T>，后者的class是多余的，会让编译器混淆
• 重写父类虚函数时一定要加override关键字，这样如果签名不匹配，编译器会直接报错，避免隐式错误
• 父类必须有虚析构函数，否则当你用Sorter<T>*指针指向子类对象并销毁时，子类的析构函数不会被调用，会导致内存泄漏

内容的提问来源于stack exchange，提问作者Mostafa Anwar