Passage du modèle de la classe comme paramètre

Comment puis-je passer basé sur un modèle de classe pour le constructeur d'une autre classe? Je suis en train de passer basé sur un modèle de la table de hachage de classe pour une classe menu qui va me permettre de permettre à l'utilisateur de décider du type de la table de hachage.

template <class T>
class OpenHash 
{
private: 
    vector <T> hashTab;
    vector <int> emptyCheck;
    int hashF(string);
    int hashF(int);
    int hashF(double);
    int hashF(float);
    int hashF(char); 

public:
    OpenHash(int);
    int getVectorCap();
    int addRecord (T);
    int sizeHash();
    int find(T);
    int printHash();
    int deleteEntry(T);
};

template <class T>
OpenHash<T>::OpenHash(int vecSize)
{
    hashTab.clear();
    hashTab.resize(vecSize);
    emptyCheck.resize(vecSize);
    for (int i=0; i < emptyCheck.capacity(); i++)   
    {
        emptyCheck.at(i) = 0;
    }
}

J'ai donc cette classe Ouverte de hachage qui est modélisé, car elle supposée permettre à n'importe quel type d'être ajouté, j'ai ce travail si lancer un objet dans ma main et modifier les types d'entrée etc.

int main () 
{
   cout << "Please input the size of your HashTable" << endl;
   int vecSize = 0;
   cin >> vecSize;
   cout << "Please select the type of you hash table integer, string, float, "
           "double or char." << endl;
   bool typeChosen = false; 
   string typeChoice; 
   cin >> typeChoice;
while (typeChosen == false)
{
    if (typeChoice == "int" || "integer" || "i")
    {
        OpenHash<int> newTable(vecSize);
        typeChosen = true;
    }
    else if (typeChoice == "string" || "s")
    {
        OpenHash<string> newTable(vecSize);
       hashMenu<OpenHash> menu(newTable);
        typeChosen = true;

    }
    else if (typeChoice == "float" || "f")
    {
        OpenHash<float> newTable(vecSize);
        typeChosen = true; 
    }
    else if (typeChoice == "double" || "d")
    {
        OpenHash<double> newTable(vecSize);
        typeChosen = true;
    }
    else if (typeChoice == "char" || "c" || "character")
    {
        OpenHash<char> newTable(vecSize);
        typeChosen = true; 
    }
    else 
    {
        cout << "Incorrect type";
    }
}
return 0;
}

Dans mon main je veux demander à l'utilisateur quel type elles pour faire la table de hachage. en fonction de ce qu'ils entrer il doit créer une instance de cette classe avec le type qu'ils veulent et ensuite la transmettre à une autre classe appelée menu qui devrait leur permettre d'appeler des fonctions de la classe hash.

Voulez-vous passer à un modèle de classe ou d'une classe template de la spécialisation? E. g. std::less ou std::less<int>?
hashF est ma fonction de hachage. et je veux passer une classe qui est modélisé.

OriginalL'auteur Shaun1810 | 2013-10-29

  1. 15

    Vous pouvez utiliser:

    class Ctor {
public:
    Ctor(const Other<int>&);    //if you know the specific type
};

    ou:

    class Ctor {
public:
    template<class T> 
    Ctor(const Other<T>&);      //if you don't know the specific type
};

    démo

    OriginalL'auteur Shoe