0

我遇到了一些问题，可以通过以下代码恢复：

template <typename Key, typename Data, typename fct>
size_t wrapper(const std::pair<Key, Data> & p)
{
  return fct(p.first);
}

int main(int argc, char *argv[])
{
  size_t val = 
    wrapper<int, int, dft_hash_fct<int>>(std::pair<int,int>(5,9));

  return 0;
}

我正在使用 clang 编译器 3.4 版，此代码无法编译并出现以下错误

test-tmp.C:17:5: error: no matching function for call to 'wrapper'
    wrapper<int, int, dft_hash_fct<int>>(std::pair<int,int>(5,9));
    ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
test-tmp.C:9:8: note: candidate template ignored: invalid explicitly-specified argument
      for template parameter 'fct'

这个想法是包装一个散列函数（模板参数fct）std::pair只取第一个字段。

dft_hash_fct是另一个模板定义如下：

template <typename Key>
size_t dft_hash_fct(const Key & key)
{
  return SuperFastHash(key);
}

这个通用函数有效；它已在其他情况下使用。

所有这些的目的是重用基于散列的集合（而不是映射）作为任何类型项目的键映射。基于散列的 ser 在构建时接收散列函数。

感谢您的评论（大卫、安德烈和卡扎克）

编辑：

好吧，我明白了，typename fct 是一个类型，所以我不能作为指针函数处理；对不起琐事。不幸的是，我认为在包装器中将函数作为参数传递的方法不起作用，因为哈希集需要一个具有以下签名的函数指针：

size_t (*the_function)(const Key & key);

因此，由于您的观察，意识到这一点，我将相关代码更改为：

template <typename Key, typename Data, size_t (*fct)(const Key & k)>
size_t wrapper(const std::pair<Key, Data> & p)
{
  return (*fct)(p.first);
}

int main(int argc, char *argv[])
{
  size_t val = 
    wrapper<int, int, dft_hash_fct<int>>(std::pair<int,int>(5,9));

  return 0;
}

编译，链接和运行。另外，我把这一行：

size_t (*fct)(const std::pair<int, int>&) = 
    wrapper<int, int, dft_hash_fct<int>>;

cout <<  (*fct)(std::pair<int, int>(4,6)) << endl;

并且编译，链接 ans 也运行。所以，我可以说编译器（当然根据语言）可以实例化函数并处理指向它的函数指针。

所以，在那之后我尝试修改我的原始代码，这是一个 HashSet 的派生类，用于管理由第一个字段散列的对。

我声明一些为：

template <typename Key, typename Data>
class HashMap : public HashSet<std::pair<Key, Data>>
{
  ...
  HashMap(size_t (*function)(const Key & key))
    : HashSet<Key, Data>(wrapper<Key, Data, function>)
  {

  }

..
};

但是编译（使用 std=c++11）失败并出现错误

./tpl_dynSetHash.H:353:7: error: no matching constructor for initialization of
      'HashSet<std::pair<unsigned long, long>>'
    : HashSet<std::pair<Key,Data>(
      ^
testDynSetHash.C:178:8: note: in instantiation of member function
      'HashMap<unsigned long, long>::HashMap' requested here
  HMap table;

但是，如果我将调用替换为基础构造函数

: HashSet<Key, Data>(wrapper<Key, Data, dft_hash_fct<Key>)

这编译得很好。因此，我认为问题出在参数类型声明上（但我不知道是什么）。

4

3 回答 3

4

传递函数的标准习惯用法是将它们作为函数对象传递，例如

template <typename Key, typename Data, typename Fct>
size_t wrapper(const std::pair<Key, Data> & p, Fct fct)
{
  return fct(p.first);
}

然后使用以下方法调用包装器：

int main(int argc, char *argv[])
{
  // no explicit template arguments required
  size_t val = 
    wrapper(std::pair<int,int>(5,9), &dft_hash_fct<int>);

  return 0;
}

另一方面，在您的代码中：

template <typename Key, typename Data, typename fct>
size_t wrapper(const std::pair<Key, Data> & p)
{
  return fct(p.first);
}

typename fct为类型引入别名。在这个函数内部，fct命名一个类型；因此fct(p.first)创建了一个 类型的对象fct，并且这个对象需要转换为 asize_t才能从wrapper. 您也可以使用它，但您必须使用的类型必须如下所示：

struct dft_hash_fct_t
{
    size_t result;
    dft_hash_fct_t(int p) : result(SuperFashHash(p)) {}
    operator size_t() const { return result; }
};

这可能不是你想要的。

于 2013-09-06T19:29:10.777 回答
1

中的模板声明

template <typename Key, typename Data, typename fct>
size_t wrapper(const std::pair<Key, Data> & p)
{
  return fct(p.first);
}

将模板参数声明fct为类型，但您试图将函数指针传递给它。您可以fct像这样制作函数指针模板参数：

template <typename Key, typename Data, size_t(*fct)(const Key&)>
size_t wrapper(const std::pair<Key, Data> & p)
{
  return fct(p.first);
}

然而，更惯用的方式是（正如 DyP 所说）传递一个函数对象，以便该函数与函数指针以及对象重载一起工作operator()：

template <typename Key, typename Data, typename Fct>
size_t wrapper(const std::pair<Key, Data> & p, Fct fct)
{
  return fct(p.first);
}

然后在调用它时将函数作为参数传递

wrapper(std::pair<int,int>(5,9), dft_hash_fct<int>);
于 2013-09-06T19:37:45.080 回答
1

您编写的代码在您的意图上下文中毫无意义。您的fct模板参数是type。这意味着

return fct(p.first);

是一种函数式强制转换，而不是()运算符的应用（即它不是函数调用）。在您的代码中，您尝试强制转换p.first为类型fct，然后尝试将该强制转换的结果返回为size_t. 那是你的意图吗？我怀疑是这样的。最重要的是，您正在尝试将函数指针值 dft_hash_fct<int>作为模板参数fct传递，即您正在传递一个预期类型的​​值。你期望它如何工作？

您提供的描述似乎暗示您实际上想fct从内部调用具有类型的函子，wrapper而不是执行强制转换。为了做到这一点，你必须以某种方式获得函子本身。再次记住，这fct不是函子，它只是函子的类型。

典型的方法是从外部传递函子，作为函数参数

template <typename Key, typename Data, typename fct>
size_t wrapper(const std::pair<Key, Data> & p, fct f)
{
  return f(p.first);
}

现在您可以将wrapper模板与基于类的函子以及普通函数一起使用

size_t val = wrapper(std::pair<int,int>(5,9), dft_hash_fct<int>);

请注意，dft_hash_fct<int>必须作为函数参数提供，而不是作为模板参数。无需显式指定模板参数，因为它们将由编译器推导出。

于 2013-09-06T19:53:02.997 回答