1

引数リストにテンプレート クラスを持つ関数のテンプレートを作成することはできますか?

statSelection() と statInsertion() の 1 つのテンプレートを作成して、テストしている並べ替えアルゴリズムの種類ごとに個別の 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();
}
4

4 に答える 4

2

私はむしろポリモーフィズムを使用したいと思います。 (多型のない解は、水平ルールの後に見つけることができます)

とという抽象クラス (インターフェース) からInsertion<_Tp>とを継承し、名前とメンバー関数を単純に(Sortable<_Tp> の仮想メンバー関数) として継承します。Selection<_Tp>ISortable<_Tp>.InsertionSort.SelectionSort.Sort

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

ポリモーフィズムのないソリューション:

sort 関数と 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);
于 2012-12-03T19:58:05.490 に答える
1

何を求めているのかは明確ではありませんが、これはクラス テンプレート パラメーターを持つ関数テンプレートです。

// 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);
于 2012-12-03T19:56:49.763 に答える
1

もしかしてこういうこと？

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);
于 2012-12-03T19:57:39.963 に答える
0

次のようなクラスを使用できます。

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

次に、このクラスから継承して、並べ替え機能を実装できます。これにより、統計関数を変更せずにソートアルゴリズムを非常に簡単に変更できます。

その呼ばれる戦略パターンを参照してください: http://en.wikipedia.org/wiki/Strategy_pattern

于 2012-12-03T20:05:57.930 に答える