模板函數：如何使用模板類作爲參數來創建模板函數？

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