C++ 带有<；级别可比>；在C++；

我试图比较算法。我对C++不太熟悉。我想创建一个main，其中包含以下代码作为标题。不过，我并不完全理解什么是“模板类可比”

#include <vector>
using namespace std;

template <class Comparable> 
void SelectionSort(vector<Comparable> & nums, int low, int high)
{
    for (int i = low; i <= high-1; i++) {
        int indexOfMin = i;                     // traverse the list to
        for (int j = i+1; j <= high; j++) {     // find the index of the
            if (nums[j] < nums[indexOfMin]) {   // next smallest item
                indexOfMin = j;
            }
        }

        Comparable temp = nums[i];              // swap the next smallest
        nums[i] = nums[indexOfMin];             // item into its correct
        nums[indexOfMin] = temp;                // position
    }
}

template <class Comparable> void SelectionSort(vector<Comparable> & nums) 
{
    SelectionSort(nums, 0, nums.size()-1);
}

#包括
使用名称空间std；
模板
无效选择排序（向量和整数、整数低位、整数高位）
{
对于（inti=low；i您的主要排序函数，如下所示（暂时剪掉“模板”部分）：

void SelectionSort（向量和nums）
{
选择排序（nums，0，nums.size（）-1）；
}

看起来像一个作用于可比向量的普通排序函数。但什么是可比函数？想象一下，如果“可比”只不过是“int”的别名（不是，但想象一下）。那么你会有这样的结果：

void SelectionSort(vector<int> & nums) 
{
    SelectionSort(nums, 0, nums.size()-1);
}

void SelectionSort（向量和nums）
{
选择排序（nums，0，nums.size（）-1）；
}

这是普通C++代码，它声明并定义了一个函数，它对int的向量进行排序。非常简单。< /P>
Comparable没有这样的标准含义。它是由您问题中的代码发明的术语。它由文本
模板
声明，与变量的声明方式大致相同。它类似于“类型变量”。普通变量表示多个值中的一个；类型变量表示多个类型中的一个

template <class Comparable> void SelectionSort(vector<Comparable> & nums) 
{
    SelectionSort(nums, 0, nums.size()-1);
}

模板无效选择排序（向量和nums）
{
选择排序（nums，0，nums.size（）-1）；
}

此代码声明Compariable不是自动的int、float或std:：string，而是可以是任何类型。要使用此函数，必须在调用函数时指定所需的类型。可以显式执行此操作：

std::vector<int> someints;
SelectionSort<int>(someints);

std:：vector someints；
选择排序（某些点）；

（这将使“可比”在一次调用中毕竟意味着“int”。）

或者，您可以省略该额外规范，并希望编译器能够解决它：

std::vector<int> someints;
SelectionSort(someints);

std:：vector someints；
选择排序（某些点）；

您可以根据需要对不同的类型使用相同的模板；一次使用不会“消耗”任何意义上的模板：

std::vector<int> someints, moreints;
std::vector<float> somefloats;
SelectionSort(someints);
SelectionSort(somefloats);
SelectionSort(moreints);

std:：vector someints，moreints；
向量浮点数；
选择排序（某些点）；
选择排序（某些浮动）；
选择排序（moreints）；

对于这样一个简单的目的，您可以想象SelectionSort是一个可以在多种类型上工作的函数，而不仅仅是一种。但实际上它不是一个函数。它是一个潜在函数的完整家族，其中一些可能由编译器实例化。上面的代码调用SelectionSort三次，但只有两种可比较的类型，一个所以在幕后它创建了两个实际的函数

我一直在说Compariable是一个变量，但它不能在模板的实例中变化。你不能在
SelectionSort
中做
Compariable=float
或类似的事情。它在模板的一个实例到另一个实例中变化，而不是在一个实例中。当模板被实例化为实函数时，CompArrable被为它指定的类型替换，然后被遗忘；该函数不“知道”它是模板的实例。它只是一个名称中碰巧有尖括号的函数。我想

确实有一些非常强大、复杂、令人费解的事情可以用模板来完成，但是你可能不需要了解太多

不过，还有一个更重要的基本点是，也有模板类。std:：vector本身就是其中之一。它们的工作方式与SelectionSort之类的模板函数大致类似：标题
对所有类型只声明一次向量模板，但您可以说
std:：vector
，然后再说
stD:：向量等等，并由此自动实例化两个（或更多）实际类。所有这些类都将像C++向量一样工作，但是每个类只知道如何处理自己指定的元素类型，并且不会理解其他任何东西。
 < P>你的主要排序函数看起来像这样（截断“模板””部分（目前）：

void SelectionSort（向量和nums）
{
选择排序（nums，0，nums.size（）-1）；
}

看起来像一个作用于可比向量的普通排序函数。但什么是可比函数？想象一下，如果“可比”只不过是“int”的别名（不是，但想象一下）。那么你会有这样的结果：

void SelectionSort(vector<int> & nums) 
{
    SelectionSort(nums, 0, nums.size()-1);
}

void SelectionSort（向量和nums）
{
选择排序（nums，0，nums.size（）-1）；
}

这是普通C++代码，它声明并定义了一个函数，它对int的向量进行排序。非常简单。< /P>
Comparable没有这样的标准含义。它是由您问题中的代码发明的术语。它由文本
模板
声明，与变量的声明方式大致相同。它类似于“类型变量”。普通变量表示多个值中的一个；类型变量表示多个类型中的一个

template <class Comparable> void SelectionSort(vector<Comparable> & nums) 
{
    SelectionSort(nums, 0, nums.size()-1);
}

模板无效选择排序（向量和nums）
{
选择排序（nums，0，nums.size（）-1）；
}

此代码声明Compariable不是自动的int、float或std:：string，而是可以是任何类型。要使用此函数，必须在调用函数时指定所需的类型。可以显式执行此操作：

std::vector<int> someints;
SelectionSort<int>(someints);

std:：vector someints；
选择排序（某些点）；

（这将使“可比”在一次调用中毕竟意味着“int”。）

或者，您可以省略该额外规范，并希望编译器能够解决它：

std::vector<int> someints;
SelectionSort(someints);

std:：vector someints；
选择排序（某些点）；

您可以根据需要对不同的类型使用相同的模板；一次使用不会“消耗”任何意义上的模板：

std::vector<int> someints, moreints;
std::vector<float> somefloats;
SelectionSort(someints);
SelectionSort(somefloats);
SelectionSort(moreints);

std:：vector someints，moreints；
向量浮点数；
选择排序（某些点）；
选择排序（某些浮动）；
选择排序（mo）