对类和多态性的怀疑

Question

我正在尝试使用链接方法在 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 中，我需要构建两个不同的哈希表，一个散列整数，另一个散列字符串。

我的疑惑是：

1. 对我来说，一个自然的选择是通过以下方式将多态性用于哈希函数（请注意，我对类和多态性的经验有限）：

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"
    }
}

但这不起作用，因为StringHashFunc 中的operator()(string name) 具有不同的参数，因此不会覆盖基类中的virtual 方法。如何使这项工作？

1. 我不确定如何在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*/);
  }
}

或者有更好的方法吗？

1. 有没有更好更自然的方法来做我想做的事？例如，我尝试使用单个类 HashFunc 和两个重载 operator()(int) 和 operator()(string)，但如果我只使用整数，我不想“携带”字符串参数和方法。

Answer 1

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*/);

有没有更好更自然的方式来做我想做的事？例如，我尝试使用具有两个重载 operator()(int) 和 operator()(string) 的单个类 HashFunc，但如果我只使用整数，我不想“携带”字符串参数和方法.

是的，使用模板，就像标准库哈希表（又名。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，它正是这样做的，但已经实现了。

Answer 2

使用基于策略的设计，它会简单得多。

首先创建您的哈希函数对象：

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 类会将哈希函数作为模板参数。

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