如何解决对类和多态性的怀疑
我正在尝试使用链接方法在C ++中构建哈希表类，一个最小的示例类是：
template <class V>
class HashTable {
private:
//some parameters to define the hash_table
HashFunc * h; //family of hash functions
public:
/*other functions*/
};
我遇到成员HashFunc * h的麻烦，这是我打算用来在哈希表中存储对main中，我需要构建两个不同的哈希表，一个哈希表对整数进行哈希处理，另一个哈希表对字符串进行哈希处理。
我的疑问是：
- 对我来说，自然的选择是以下列方式对哈希函数使用多态性（请注意，我对类和多态性的经验有限）：
class HashFunc{
public:
virtual int operator()()=0;
}
class IntegerHashFunc: public HashFunc
{
//parameters to hash integers
public:
int operator()(int x){
//operations for integer hashing
}
}
class StringHashFunc: public HashFunc
{
//parameters to hash strings
IntegerHashFunc h_integer; //string->integer->integer hash
public:
int operator()(string name){
int result=0;
//operations for string hashing
return h_integer(result); //I need to hash the integer resulting from string "hashing"
}
}
但这不会起作用，因为operator()(string name)中的StringHashFunc具有不同的参数，因此不会覆盖基类中的virtual方法。如何进行这项工作？
- 我不确定如何在
HashTable类的构造函数中实现此功能：如何在两种方法之间进行选择？我是否应该在构造函数中使用标志，例如：
template<class V>
HashTable<V>::HashTable(/*args*/,int flag){
//other parameters
switch(flag){
case 1:
h=new IntegerHashFunc(/*args for integer hashing*/);
case 2:
h=new StringHashFunc(/*args for string hashing*/);
}
}
还是有更好的方法？
- 是否有更好，更自然的方式来做我想做的事情？例如，我尝试使用具有两个重载
HashFunc和operator()(int)的单个类operator()(string)，但是如果我只是在工作，我不想“随身携带”字符串参数和方法带有整数。
解决方法
TL; DR-所有问题的答案是“使用模板，而不是多态”。
对我来说，自然的选择是以下列方式对哈希函数使用多态性（请注意，我对类和多态性的经验有限）：
但这是行不通的，因为StringHashFunc中的operator（）（string name）具有不同的参数，因此不会覆盖基类中的虚方法。如何进行这项工作？
您不能。为了使派生类成为非抽象类，您需要重写所有纯虚函数。即使使用参数添加了另一个重载，它也无济于事，因为您无法使用基类指针来调用这些重载。
从理论上讲，您可以执行dynamic_cast来确定实际类型是什么（在很长的if语句链中），但是不建议这样做。
我不确定如何在HashTable类的构造函数中实现此功能：如何在这两种方法之间进行选择？我是否应该在构造函数中使用标志，例如：
还是有更好的方法？
一种选择是使用类型特征选择正确的分支（假设您确实非常想使用多态性）：
if(std::is_same_v<V,int>)
h=new IntegerHashFunc(/*args for integer hashing*/);
else if(std::is_same_v<V,std::string>)
h=new StringHashFunc(/*args for string hashing*/);
是否有更好，更自然的方式来做我想做的事情？例如，我尝试使用带有两个重载的单个类HashFunc运算符（）（int）和operator（）（string），但是如果我只使用整数，我不想“携带”字符串参数和方法
是的，使用模板，就像标准库哈希表（又名std::unordered_map）一样：
template<typename T>
class HashFunc{
public:
int operator()(const T&) const;
};
template<>
class HashFunc<int>{
public:
int operator()(const int&) const {
// do calculations for int
}
};
template<>
class HashFunc<std::string>{
public:
int operator()(const std::string&) const {
// do calculations for std::string
}
};
//etc... for all other specializations
template <class V>
class HashTable {
private:
//some parameters to define the hash_table
HashFunc<V> h; //family of hash functions
public:
/*other functions*/
};
或更妙的是，使用已经存在的std::hash，它可以做到这一点，但是已经实现了。
使用基于策略的设计，它将变得更加简单。
首先创建您的哈希函数对象：
struct IntegerHashFunc
{
int operator()(int x){ return x; }
};
struct StringHashFunc
{
IntegerHashFunc h_integer; //string->integer->integer hash
int operator()(string name){
int result=0;
return h_integer(result);
}
};
您的HashTable类将把Hash函数作为模板参数。
template <typename Key,typename Val,typename HashFunctionPolicy = IntegerHashFunc>
class HashTable {
private:
//some parameters to define the hash_table
public:
/*other functions*/
void somefunction(Key key)
{
HashFunctionPolicy f;
auto x = f(key);
}
};
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。