模板函数：如何使用模板类作为参数来创建模板函数？

Question

是否有可能为在其参数列表中具有模板类的函数创建模板？

我想为statSelection（）和statInsertion（）创建一个模板，它允许我测试不同的排序算法，而不必为我测试的每种排序算法类型创建单独的stat函数。 （我的排序算法是模板类）

#include <iostream> 
#include <fstream> 
#include <iomanip> 
#include <cstdlib> 
#include <ctime> 
#include "FileGen.h" 
#include "FileRead.h" 
#include "SelectionSort.h" 
#include "SelectionSort.cpp" 
#include "InsertionSort.h" 
#include "InsertionSort.cpp" 

using namespace std; 

void statSelection(int[], int[], Selection<int>, Selection<int>); 
void statInsertion(int[], int[], Insertion<int>, Insertion<int>); 

int main() 
{ 
    FileGen fileGen; 
    FileRead fileRead; 
    Selection<int> selectHundred; 
    Selection<int> selectThousand; 
    Insertion<int> insertionHundred; 
    Insertion<int> insertionThousand; 
    int valuesHundred[100]; 
    int valuesThousand[1000]; 
    fileGen.generateFiles(); 
    fileRead.readFiles(valuesHundred, valuesThousand); 
    statSelection(valuesHundred, valuesThousand, selectHundred, selectThousand); 
    fileGen.generateFiles(); 
    fileRead.readFiles(valuesHundred, valuesThousand); 
    statInsertion(valuesHundred, valuesThousand, insertionHundred, insertionThousand); 
    system("pause"); 
    return 0; 
} 

void statSelection(int vHundred[], int vThousand[], Selection<int> sHundred, Selection<int> sThousand) 
{ 
    cout << "One Hundred Items" << endl; 
    sHundred.SelectionSort(vHundred, 100); 
    sHundred.selectionSortPreformance(); 
    cout << "One Thousand Items" << endl; 
    sThousand.SelectionSort(vThousand, 1000); 
    sThousand.selectionSortPreformance(); 
} 

void statInsertion(int vHundred[], int vThousand[], Insertion<int> iHundred, Insertion<int> iThousand) 
{ 
    cout << "One Hundred Items" << endl; 
    iHundred.InsertionSort(vHundred, 100); 
    iHundred.insertionSortPreformance(); 
    cout << "One Thousand Items" << endl; 
    iThousand.InsertionSort(vThousand, 1000); 
    iThousand.insertionSortPreformance(); 
} 

Answer 1

我宁愿使用多态性。（不含多态性的溶液可以在水平规则之后发现的）

我会从抽象类（接口）称为ISortable<_Tp>同时继承Insertion<_Tp>和Selection<_Tp>，和名称.InsertionSort和.SelectionSort成员函数简单地作为.Sort（这将是一个虚拟成员函数Sortable < _Tp>）。

template<typename _Tp> 
class ISortable<_Tp>{ 
public: 
    virtual void Sort(_Tp *, int)=0; // btw functions are usually lowercase 
    virtual void Performance()=0; 
}; 

template<typename _Tp> 
class InsertionSort<_Tp> : public Sortable<_Tp>{ 
//... 
    virtual void Sort(_Tp *, int); 
    virtual void Performance(); 
}; 
//... 

所以你的函数可以这样写：

void statSelection(int[], int[], Sortable<int>&, Sortable<int>&); 

void statSelection(int[], int[], Sortable<int>&sHundred, Sortable<int>&) 
{ 
//... 
    sHundred.Sort(vHundred, 100); 
    sHundred.Performance(); 
//... 
} 

---

解决方案，而多态性：

这是可以做到的，只是名称都被你的排序和性能功能，同名。

然后

template<typename _Tp_sortable> 
void statGeneral(int[], int[], _Tp_sortable sHundred, _Tp_sortable) 
{ 
//... 
    sHundred.Sort(vHundred, 100); 
    sHundred.Performance(); 
//... 
} 

的例子：（林不知道，如果你确实需要的功能后<Selection<int> >的一部分，但我会用它称呼它）

statGeneral<Selection<int> >(valuesHundred, valuesThousand, selectHundred, selectThousand); 
statGeneral<Insertion<int> >(valuesHundred, valuesThousand, insertionHundred, insertionThousand); 

Answer 2

你不清楚你在做什么，但是这是一个具有类模板参数的函数模板。

// class template 
template <typename T> class Foo {}; 

// function template 
template <typename T> 
T doSomething(const Foo<T>& f) { .... } 

如果你希望能够指定类模板作为模板参数，那么你需要一个“模板的模板参数”：

// class templates 
template <typename T> class Foo {}; 
template <typename T> class Bar {}; 

template <template<class> class T1, class T2> 
T2 doSomething(const T1<T2>& f); 

Foo<int> f; 
Bar<double> b; 
int n = doSomething(f); 
double x = doSomething(b); 

Answer 3

像这样的事情吧？

template <typename T> 
void statSelection(T vHundred[], T vThousand[], Selection<T> sHundred, Selection<T> sThousand); 

template <typename T> 
void statInsertion(T vHundred[], T vThousand[], Insertion<T> iHundred, Insertion<T> iThousand); 

Answer 4

可以使用像这样的一个类：

template <class T> 
class Sortclass 
{ 
public: 
    virtual void sort(T array[] , int size) = 0; 
    virtual void preformance() = 0; 
}; 

template <class T> 
class AsortClass : public Sortclass<T> 
{ 
public: 
    virtual sort(T array[] , int size) 
    { 
     //do stuff 
    } 

    virtual void preformance() 
    { 
     //do stuff 
    } 
}; 

template <class T> 
void stat(T vHundred[], T vThousand[], Sortclass<T>& iHundred, Sortclass<T>& iThousand) 
{ 
    cout << "One Hundred Items" << endl; 
    iHundred.sort(vHundred, 100); 
    iHundred.preformance(); 
    cout << "One Thousand Items" << endl; 
    iThousand.sort(vThousand, 1000); 
    iThousand.preformance(); 
}  

然后你可以继承这个类并实现排序funktion。 使用此功能，您可以在不更改统计功能的情况下轻松更改排序algorythm。

其所谓的战略格局看： http://en.wikipedia.org/wiki/Strategy_pattern