Question

我正在尝试为我正在进行的项目编写一个简短的单元测试器。

如果给定函数抛出某种异常，则该测试通过：

template <class Exception, class Return, class... Args>
bool throws(std::string s, Return(*fn)(Args...), Args... args)
{
  try
  {
    fn(args...);
  }
  catch (Exception& e)
  {
    return output(s, true);
  }
  catch (...)
  {
    return output(s, false);
  }
  return output(s, false);
}

使用它看起来像这样：

throws<int>("Testing: Throws int", &foo);

这很有效。但是现在我试图编写一个类似的函数来处理类的成员函数。

这是我到目前为止所得到的：

template <class Exception, class Object, class Return, class... Args>
bool throws(std::string s, Object& o, Return(Object::*fn)(Args...), Args... args)
{
  // ...
  (o.*fn)(args...);
  // ...
}

template <class Exception, class Object, class Return, class... Args>
bool throws(std::string s, const Object& o, Return(Object::*fn)(Args...) const, Args... args)
{ /* ... */ }

使用时应该看起来像这样：

Bar<int> b1(5), b2(2);
typedef Bar<int>& (Bar<int>::*fn)(const Bar<int>&);
typedef Bar<int> (Bar<int>::*const_fn)(const Bar<int>&) const;

fn foo = &Bar<int>::foo;
const_fn const_foo = &Bar<int>::const_foo;

throws<int>("Testing member function", b1, foo, b2);
throws<int>("Testing const member function", b1, const_foo, b2);

但是当我这样做时，我得到了＃34;没有匹配的函数调用＆＃34;对于这两个throws（）函数。具体做法是：

error: no matching function for call to ‘throws(const char [30], Bar<int>&, Bar<int> (Bar<int>::*&)(const Bar<int>&)const, const Bar<int>&)

与非const版本类似。

我注意到一些不同的竞争，所以我试着投入一些const_cast，我使用的功能，但没有骰子。这是我第一次使用成员函数指针和可变参数模板（总而言之，更不用说同时），所以我绝对可能错过了一些东西......比我更有经验的人有什么想法？< / p>

我唯一能够解释的是(Bar<int>::*&)。＆amp;在那个结尾处并不匹配电话......但这应该不是问题，是吗？

编辑：根据要求，我的吧班：

template <class T>
class Bar
{
private:
  T _data;
public:
  Bar (const int i) : _data(i) {}
  Bar const_foo (const Bar& other) const
  {
    if (_data != other._data)
    {
      throw _data;
    }
    return Bar(_data);
  }
  Bar& foo (const Bar& other)
  {
    if (_data != other._data)
    {
      throw _data;
    }
    return *this;
  }
};

完整的错误：

test.cpp: In function ‘int main()’:
test.cpp:111:53: error: no matching function for call to ‘throws(const char [24], Bar<int>&, Bar<int>& (Bar<int>::*&)(const Bar<int>&), Bar<int>&)’
test.cpp:111:53: note: candidates are:
test.cpp:31:6: note: template<class Exception, class Return, class ... Args> bool throws(std::string, Return (*)(Args ...), Args ...)
test.cpp:53:6: note: template<class Exception, class Object, class Return, class ... Args> bool throws(std::string, Object&, Return (Object::*)(Args ...), Args ...)
test.cpp:75:6: note: template<class Exception, class Object, class Return, class ... Args> bool throws(std::string, const Object&, Return (Object::*)(Args ...)const, Args ...)
test.cpp:112:65: error: no matching function for call to ‘throws(const char [30], Bar<int>&, Bar<int> (Bar<int>::*&)(const Bar<int>&)const, Bar<int>&)’
test.cpp:112:65: note: candidates are:
test.cpp:31:6: note: template<class Exception, class Return, class ... Args> bool throws(std::string, Return (*)(Args ...), Args ...)
test.cpp:53:6: note: template<class Exception, class Object, class Return, class ... Args> bool throws(std::string, Object&, Return (Object::*)(Args ...), Args ...)
test.cpp:75:6: note: template<class Exception, class Object, class Return, class ... Args> bool throws(std::string, const Object&, Return (Object::*)(Args ...)const, Args ...)

Answer 1

我注意到你使用带有零参数的函数的非成员版本。我相信当你尝试传递参数时你的代码会失败，而不是当你改变它以获取成员函数时。通过将其更改为采用成员函数并在同一步骤中传递参数，您混淆了失败的真正原因。我相信如果您使用零参数的成员函数尝试它，您的代码将会起作用。我相信如果您尝试将其与带有一个或多个参数的函数一起使用，那么您的非成员版本将会失败。

template <class Exception, class Object, class Return, class... Args>
bool throws(std::string s, Object& o, Return(Object::*fn)(Args...), Args... args)

在这里，您告诉编译器throws的第四个参数的类型和函数指针的第一个参数必须完全相同。

error: no matching function for call to ‘throws(const char [24], Bar<int>&,
       Bar<int>& (Bar<int>::*&)(const Bar<int>&), Bar<int>&)’

编译器告诉你throws的第四个参数和函数指针的第一个参数是不同的，所以它找不到匹配的throws声明。您的模板无法匹配，因为这意味着Args...必须同时推断为const Bar<int>&和Bar<int>&，这些是两种不同的类型。

@WhozCraig在评论中提供的解决方案之所以有效，是因为函数类型和参数类型是独立推导出来的。他的解决方案通过通用引用传递函数指针，但这是偶然的;它也可以通过const左值引用或值来获取函数指针。

template <class Exception, class Func, class... Args>
bool throws(std::string s, Func fn, Args&&... args)
{ /*...*/ }

template <class Exception, class Object, class MemFunc, class... Args>
bool throws(std::string s, Object& o, MemFunc fn, Args&&... args)
{ /*...*/ }

不幸的是，使用这种方法可能会遇到过载不明确的情况。对此的简单解决方案是重命名成员版本memberThrows。更复杂的版本是使用标签发送或SFINAE（在这种情况下我更喜欢前者）。

template <class Exception, class Func, class... Args>
bool throwsHelper(std::false_type, std::string s, Func fn, Args&&... args)
{ /*...*/ }

template <class Exception, class MemFunc, class Object, class... Args>
bool throwsHelper(std::true_type, std::string s, MemFunc fn, Object&& o, Args&&... args)
{ /*...*/ }

template <class Exception, class Func, class... Args>
bool throws(std::string s, Func fn, Args&&... args)
{
    using isMember = typename std::is_member_pointer<Func>::type;
    return throwsHelper(isMember(), s, fn, std::forward<Args>(args)...);
}

请注意，我必须更改成员版本的参数顺序，以便在两种情况下都允许统一调用。

Answer 2

确保Bar<int>::const_foo是const成员函数，并且返回类型为Bar<int>（而不是引用）。如果这不是问题，请发布更多代码。

C ++：具有可变参数模板的成员函数指针参数

2 个答案: