2

在回答问题时，我建议使用模板别名来定义成员函数的签名；也就是说，不仅仅是类型定义一个成员函数，而且能够分解出包含该方法的目标类：

template<typename T>
using memberf_pointer = int (T::*)(int, int);

尽管这似乎涵盖了问题的内容，但我尝试将其概括为任意函数参数：

template<typename T, typename... Args>
using memberf_pointer = int (T::*)(Args&&...);

它因参数推导问题而失败（基本上它假定一个空参数列表）。这是一个演示：

#include <iostream>

class foo
{
public:
  int g (int x, int y) { return x + y ; }
};

template<typename T, typename...Args>
using memberf_pointer = int (T::*)(Args&&...); 

int main()
{
  foo f ;
  memberf_pointer<foo> mp = &foo::g ;
  std::cout << (f.*mp) (5, 8) << std::endl ;
}

为什么是这样？有没有办法让它工作？

4

4 回答 4

1

在这种情况下，为什么不简单地使用汽车呢？在这种情况下，拥有模板的唯一优点是能够显式地提供您的类型。

另一方面，如果您希望您的模板自动推断出函数类型，则需要直接在该类型上对其进行参数化。如果您还希望它为您提供所有构建块，最简单的方法是将其专门用于函数或成员函数。例子：

template<typename T> struct memberf_pointer_descriptor;

template<typename TOwner, typename TRet, typename... Args>
struct memberf_pointer_descriptor<TRet(TOwner::*)(Args...)>
{
    // Your stuff goes here.
    using type = TRet(TOwner::*)(Args...);
};

memberf_pointer_descriptor<decltype(&foo::g)>;

或者直接将 foo::g 作为参数的函数模板，以减少使用显式 decltype 的需要。取决于你的需要。

于 2015-07-27T10:23:20.723 回答
1

使您的示例工作的一种方法如下：

#include <iostream>

class foo
{
public:
    int g(int x, int y) { return x + y; }
};

template<typename T, typename...Args>
using memberf_pointer = int (T::*)(Args...);

int main()
{
    foo f;
    memberf_pointer<foo, int, int> mp = &foo::g;
    std::cout << (f.*mp) (5, 8) << std::endl;
}

它删除了对可变参数模板参数的引用，并且在实例化 memberf_pointer 时它还提供了成员函数参数。但auto可能是要走的路...

于 2015-07-27T10:26:56.873 回答
1

C++ 没有像Hindley-Milner类型推导系统这样的功能，它不适用于您的特定右值分配

memberf_pointer<foo> mp = &foo::g ;

至于一些快速的解决方法，你可以

  1. 只需删除整个结构并使用auto

    auto mp = &foo::g;

  2. 显式提供类型或指针类型

    template<typename T>
using memberf_pointer = T;

memberf_pointer<decltype(&foo::g)> mp = &foo::g;

参照。模板参数推导

于 2015-07-27T10:52:43.487 回答
1

问题标题和正文中的措辞非常具有误导性。在您的示例中，任何地方都在进行零模板扣除。当你写：

memberf_pointer<foo> mp = &foo::g;

memberf_pointer<foo>是一个别名模板，是的，但它是一个特定的实例。没有扣除，因为您提供的是mp. 该行完全等同于：

int (foo:*mp)() = &foo::g;

g由于需要参数的明显原因，它不能编译。在赋值语句中获取模板推导的方法是使用auto：

auto mp = &foo::g;

的类型mp将与U您调用的类型相同：

template <typename U> void meow(U );
meow(&foo::g);

也就是说，int (foo::*)(int, int).

同样，您可以这样做：

decltype(&foo::g) mp = &foo::g;

这会给你和以前一样的类型。

当然，即使您提供了正确的参数列表：

memberf_pointer<foo, int, int> mp = &foo::g;

这仍然无法编译，因为您的别名添加了对两个参数的右值引用。那里的类​​型mp是int (foo::*)(int&&, int&&)，不匹配&foo::g的。也许您打算将其视为通过转发引用进行的推断，但此处并非如此。为了正确使用别名，您必须重写它：

template<typename T, typename...Args>
using memberf_pointer = int (T::*)(Args...); 

memberf_pointer<foo, int, int> mp = &foo::g;

如果我们有一个接受右值引用的成员函数，那么我们可以显式地提供它：

class bar
{
public:
  int h(int&& x, int&& y) { return x + y ; }
};

memberf_pointer<bar, int&&, int&&> mb = &bar::h;
于 2015-07-27T14:14:52.027 回答