template<class T> void sort(T& a, int n) { for (int i = 0; i < n-1; i++) { if (a[i] < a[i + 1]) { int temp = a[i]; a[i] = a[i + 1]; a[i + 1] = temp; } } }

这段代码实现的是一个简单的冒泡排序算法，它的基本思想是通过不断交换相邻的元素来将最大的元素放到数组的末尾，然后再对剩余的元素进行同样的操作，直到整个数组都有序为止。

具体实现步骤如下：
1. 从数组的第一个元素开始，依次比较相邻的两个元素，如果前面的元素比后面的元素大，则交换它们的位置；
2. 重复上述步骤，每次比较的元素个数减一，直到只剩下一个元素为止。

以下是冒泡排序的C++实现代码：

template<class T>
void bubbleSort(T& a, int n) {
    for (int i = 0; i < n - 1; i++) {  // 外层循环控制比较的轮数
        for (int j = 0; j < n - i - 1; j++) {  // 内层循环控制每轮比较的次数
            if (a[j] < a[j + 1]) {  // 如果前面的元素比后面的元素大，则交换它们的位置
                int temp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = temp;
            }
        }
    }
}

需要注意的是，这段代码中使用了模板（template）来实现通用的排序函数，可以对不同类型的数组进行排序。

相关问题

如下类声明有何错误#include<iostream> using namespace std; const int MAX_SIZE = 5; template<class T> class Array { T* pData; int nSize; public: Array(int n); //构造函数 ~Array(); //析构函数 //下标运算符重载 T& operator[](int idx){ return pData[idx]; } int Find(T& obj); //查找函数 void Sort(); //排序函数 }; template<class T> Array::Array(int n) { pData=new T[n]; nSize=n; } template<class T> int Array::Find(T& obj) { int i=0; for(;i<nSize;i++) { if(pData[i]==obj) return i; } return -1; } template<class T> void Array::Sort() { for(int i=0;i<nSize;i++) for(int j=0;j<nSize-i-1;j++) if(pDate[j]>pData[j+1]) { T t=pData[j]; pData[j]=pData[j+1]; pData[j+1]=t; } }

该类声明有以下错误：

1. 在类的模板函数实现中，应该在函数名后加上模板参数列表，例如：

template<class T>
Array<T>::Array(int n) {
    pData = new T[n];
    nSize = n;
}

2. 在类的模板函数实现中，应该在类名后加上模板参数列表，例如：

template<class T>
int Array<T>::Find(T& obj) {
    int i = 0;
    for (; i < nSize; i++) {
        if (pData[i] == obj)
            return i;
    }
    return -1;
}

3. 在类的模板函数实现中，应该在类名后加上模板参数列表，例如：

template<class T>
void Array<T>::Sort() {
    for (int i = 0; i < nSize; i++)
        for (int j = 0; j < nSize - i - 1; j++)
            if (pData[j] > pData[j + 1]) {
                T t = pData[j];
                pData[j] = pData[j + 1];
                pData[j + 1] = t;
            }
}

4. 在类的构造函数和析构函数中，应该在类名后加上模板参数列表，例如：

template<class T>
Array<T>::Array(int n) {
    pData = new T[n];
    nSize = n;
}

template<class T>
Array<T>::~Array() {
    delete[] pData;
}

5. 在类声明中，应该在模板参数列表后加上类名，例如：

template<class T>
class Array {
    T* pData;
    int nSize;
public:
    Array(int n);        //构造函数
    ~Array();                //析构函数
    T& operator[](int idx); //下标运算符重载
    int Find(T& obj);        //查找函数
    void Sort();                //排序函数
};

问题 C: 函数模板之排序2 [命题人 : admin] 时间限制 : 1.000 sec 内存限制 : 128 MB 题目描述 补充程序，使得输出符合规定的要求。 定义学生类Student（包含成员变量：姓名name、成绩score），以及相关的函数。 排序依旧只使用一个函数模板。 #include<iostream> #include<string> #include<iomanip> using namespace std; // 在这里补充你的代码 template<typename T> void Input(T a[], int n) { for (int i = 0; i < n; i++) cin >> a[i]; } template<typename T> void Show(T a[], int n) { for (int i = 0; i < n; i++) cout << a[i] << ((i < n - 1) ? " " : "\n"); } int main() { const int N = 6; { long a[N]; Input(a, N); Show(a, N); Sort(a, N); Show(a, N); } cout << "-" << endl; { Student a[N]; Input(a, N); Show(a, N); Sort(a, N); Show(a, N); } return 0; }

根据题目描述，需要定义一个学生类 `Student`，包含成员变量 `name` 和 `score`，同时需要完成函数模板 `Sort`。

下面是完整的代码实现，其中包含了 `Student` 类和 `Sort` 函数模板的定义：

#include<iostream>
#include<string>
#include<iomanip>
using namespace std;

class Student {
public:
    string name;
    int score;

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

    friend istream& operator >> (istream& is, Student& s) {
        is >> s.name >> s.score;
        return is;
    }

    friend ostream& operator << (ostream& os, const Student& s) {
        os << s.name << " " << s.score;
        return os;
    }
};

template<typename T>
void Input(T a[], int n) {
    for (int i = 0; i < n; i++)
        cin >> a[i];
}

template<typename T>
void Sort(T a[], int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = i + 1; j < n; j++) {
            if (a[j] < a[i]) {
                T temp = a[j];
                a[j] = a[i];
                a[i] = temp;
            }
        }
    }
}

template<typename T>
void Show(T a[], int n) {
    for (int i = 0; i < n; i++)
        cout << a[i] << ((i < n - 1) ? " " : "\n");
}

int main() {
    const int N = 6;

    {
        long a[N];
        Input(a, N);
        Show(a, N);
        Sort(a, N);
        Show(a, N);
    }

    cout << "-" << endl;

    {
        Student a[N];
        Input(a, N);
        Show(a, N);
        Sort(a, N);
        Show(a, N);
    }

    return 0;
}

在这个实现中，`Student` 类包含了 `name` 和 `score` 两个成员变量，同时还重载了 `<` 运算符，以便在 `Sort` 函数中进行排序。`Sort` 函数模板使用冒泡排序来对数组进行排序。`Input` 和 `Show` 函数与原来的实现相同，不做过多解释。