Question

此问题仅供测试之用，仅此而已。

我目前正在尝试使用不同数量的参数存储函数指针（这些参数可以有不同的类型）。

基本上，我在C ++ 11中编写了以下代码片段：

#include <functional>
#include <iostream>

void fct(int nb, char c, int nb2, int nb3) {
  std::cout << nb << c << nb2 << nb3 << std::endl;
}

template <typename... Args>
void call(void (*f)(), Args... args) {
  (reinterpret_cast<void(*)(Args...)>(f))(args...);
}

int main(void) {
  call(reinterpret_cast<void(*)()>(&fct), 42, 'c', 19, 94);
}

我将void(*)(int, char, int, int)函数指针转换为通用void(*)()函数指针。然后，通过使用可变参数模板参数，我只需将函数指针重新设置为其原始类型，并使用一些参数调用该函数。

此代码编译并运行。大多数时候，它显示出良好的价值。但是，这段代码在Mac OS下给我一些Valgrind错误（关于未初始化的值），它有时会显示一些意外的垃圾。

==52187== Conditional jump or move depends on uninitialised value(s)
==52187==    at 0x1004E4C3F: _platform_memchr$VARIANT$Haswell (in /usr/lib/system/libsystem_platform.dylib)
==52187==    by 0x1002D8B96: __sfvwrite (in /usr/lib/system/libsystem_c.dylib)
==52187==    by 0x1002D90AA: fwrite (in /usr/lib/system/libsystem_c.dylib)
==52187==    by 0x100025D29: std::__1::__stdoutbuf<char>::overflow(int) (in /usr/lib/libc++.1.dylib)
==52187==    by 0x10001B91C: std::__1::basic_streambuf<char, std::__1::char_traits<char> >::xsputn(char const*, long) (in /usr/lib/libc++.1.dylib)
==52187==    by 0x10003BDB0: std::__1::ostreambuf_iterator<char, std::__1::char_traits<char> > std::__1::__pad_and_output<char, std::__1::char_traits<char> >(std::__1::ostreambuf_iterator<char, std::__1::char_traits<char> >, char const*, char const*, char const*, std::__1::ios_base&, char) (in /usr/lib/libc++.1.dylib)
==52187==    by 0x10003B9A7: std::__1::num_put<char, std::__1::ostreambuf_iterator<char, std::__1::char_traits<char> > >::do_put(std::__1::ostreambuf_iterator<char, std::__1::char_traits<char> >, std::__1::ios_base&, char, long) const (in /usr/lib/libc++.1.dylib)
==52187==    by 0x1000217A4: std::__1::basic_ostream<char, std::__1::char_traits<char> >::operator<<(int) (in /usr/lib/libc++.1.dylib)
==52187==    by 0x1000011E8: fct(int, char, int, int) (in ./a.out)
==52187==    by 0x1000013C2: void call<int, char, int, int>(void (*)(), int, char, int, int) (in ./a.out)
==52187==    by 0x100001257: main (in ./a.out)

我觉得这很好奇，因为当我调用该函数时，我已经将函数指针重新设置为其原始类型。我认为它类似于将数据类型转换为void*，然后将其重新转换为原始数据类型。

我的代码出了什么问题？我们不能将函数指针强制转换为void(*)()指针，然后将此指针重新转换为原始函数指针签名吗？

如果没有，是否还有其他方法可以实现这一目标？我对std::bind不感兴趣，而不是我想要的。

Answer 1

你说你也对替代实施感兴趣。就个人而言，即使它完美运行，我也不会以这种方式实现它，函数指针和reinterpret_cast都是我试图避免的。我还没有测试过这段代码，但我的想法是：

#include <functional>
#include <iostream>
#include <boost/any.hpp>

template <typename... Args>
void call(boost::any clbl, Args... args) {
  auto f = boost::any_cast<std::function<void(Args...)>>(clbl);
  f(args...);
}

int main(void) {
  std::function<void(int, char, int, int)> func = fct;
  call(boost::any(func), 42, 'c', 19, 94);
}

编辑：这段代码，结合你对fct的定义，可以正常工作，并在Fedora上的valgrind下运行，用clang35编译。

Answer 2

走出困境，猜测你做了什么让它失败......

#include <functional>
#include <iostream>

void fct(int nb, char c, int nb2, std::string nb3) {
  std::cout << nb << c << nb2 << nb3 << std::endl;
}

template <typename... Args>
void call(void (*f)(), Args... args) {
  (reinterpret_cast<void(*)(Args...)>(f))(args...);
}

int main(void) {
  call(reinterpret_cast<void(*)()>(&fct), 42, 'c', 19, "foobar");
}

这会失败因为＆＃34; foobar＆＃34;永远不会转换为std::string ...编译器如何知道它是否通过Args...？

我不确定调用者是如何将std::string推送到调用堆栈上的（字符串引用将作为指针推送），但我怀疑它不仅仅是一个指针到char*。当被叫方弹出指向char*期望整个string成员的指针时，它会吓坏。

我想如果你换到

void fct(int nb, char c, int nb2, char* nb3)

或

call(reinterpret_cast<void(*)()>(&fct), 42, 'c', 19, std::string("foobar"));

然后可能工作。

将函数指针转换为void（*）（），然后重铸为原始类型

2 个答案: