템플릿 함수 : 템플릿 클래스를 인자로 템플릿 함수를 만드는 방법은 무엇입니까?

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(); 
}  

이 클래스를 상속하고 sort funktion. 이것을 사용하면 stat 함수를 변경하지 않고도 algorythm을 쉽게 변경할 수 있습니다.

의라는 전략 패턴을 참조하십시오 http://en.wikipedia.org/wiki/Strategy_pattern