Преобразование шаблона Variadic в std:: function <R (ARGS...)> работает с GCC, а не с MSVC2013, почему?

Если это дубликат, я утверждаю. В моих поисках я ничего не нашел.

Я могу использовать любую из новейших функций С++ 11/С++ 14. При необходимости я могу перейти на VS2015.

Я пытаюсь написать класс, который будет автоматически добавлен в std:: function с определенной подписью при назначении. У меня есть код, который работает с GCC, но это не удалось на MSVC2013. Код - это фрагмент, который воссоздает ошибку. WTF MSVC?!

Кроме того, я знаю, что это рискованный код, автоматически набрасывая указатели на функции и т.д., но это для частной реализации библиотеки плагинов, и я только хочу определить подпись функции один раз.

Если есть другой способ написать код, который выполняет те же функции в main() и работает на обоих, я все уши.

MSVC терпит неудачу с той же ошибкой, когда у меня есть это...

Ошибка MSVC со следующей ошибкой в файле, который трудно читать, если не сказать больше. Кажется, он выводит неправильную сигнатуру функции.

Ответы

Ответ 1

Это другой подход к решению вашей проблемы. Если мое понимание возможностей MSVC 2015 верное, оно должно работать там.

(Я предполагаю, что ваша проблема заключается в том, что вы хотите относительно прозрачно передать a void* неизвестной функции в std::function с сигнатурой, которая имеет неизвестную функцию, без необходимости повторять подпись функции.)

Вместо того, чтобы отбрасывать указатель void в точке, где мы отбрасываем std::function, вместо этого я делаю это в той точке, где вызывается функция, и вычисляется возвращаемое значение (или, когда не возвращается) трюк "возврат типа вывода":

template<class...Args>
struct void_ptr_deferred_execution_t {
  std::tuple<Args&&...> args;
  void const* pf = nullptr;
  void_ptr_deferred_execution_t( std::tuple<Args&&...> a, void const* p ):
    args(std::move(a)),
    pf(p)
  {}
  template<class R, size_t...Is>
  R invoke( std::index_sequence<Is...> ){
    using f_t = R(*)(Args...);
    f_t f = f_t(pf);
    pf = nullptr;
    return f(std::forward<Args>(std::get<Is>(args))...);
  }
  template<class R>
  operator R()&&{
    return invoke<R>( std::index_sequence_for<Args...>{} );
  }
  ~void_ptr_deferred_execution_t() {
    if (pf) invoke<void>(std::index_sequence_for<Args...>{});
  }
};

class FunctionPointer
{
  void* fp;
public:
  FunctionPointer(void* ptr)
    : fp(ptr)
  {}

  template<class...Args>
  void_ptr_deferred_execution_t<Args...>
  operator()(Args&&...args)const {
    return { std::forward_as_tuple(std::forward<Args>(args)...), fp };
  }
};

живой пример.

Когда std::function вызывает их вызываемые, они либо отбрасывают результат, либо отбрасывают его на R. Из аргументов, переданных вызываемому, плюс тип, возвращаемое значением, я могу восстановить (в основном) подпись std::function, которая вызвала меня.

В этот момент я передал свой void* в указатель на эту функцию, вызвал ее и вернул результат.

Если меня никогда не бросают на что-то, в момент разрушения я отбрасываю свой указатель на функцию возврата void, вызываю ее и делаю.

Предостережения:

Обратите внимание, что прямой вызов FunctionPointer столь же опасен, как передача его в std::function в вашем примере (крайне).

Действительно, сохранение указателя функции в std::function является излишним.

Не тестировался в MSVC2015, но я не вижу ничего, что бы не работало в MSVC2015.

Существует вероятность того, что некоторые реализации std::function могут не работать с указанным выше, если ваша функция возвращает void. Это, однако, было бы ошибкой времени компиляции.

Вышеупомянутое также предполагает, что нет функций с аргументами ссылки rvalue, поскольку в точке вызова я не могу различить, что вы вызываете из std::function<void(T)> и a std::function<void(T&&)>. Я предполагаю, что в этом случае это void(T).

Ответ 2

Вот как я мог бы избежать кастинга вне класса:

class FunctionPointer
{
 void* fp;
    public:
FunctionPointer() = default;

template<class Ret, class Fn, class... Args> void assign_fn(Fn fn, Args... args)
{
    std::function<Ret(Args...)> *f = new std::function<Ret(Args...)>;
    *f = Fn; // Tip: you can use enable_if combined with is_assignable to make sure this can be done.
    // Both are regular pointers, so conversion shouldn't be a problem.
    fp = reinterpret_cast<void*>(f);
}

// Overload casting operator to 
// a certain function signature
template<class R, class... ARGS>
operator std::function<R(ARGS...)>(){
    typedef R(*func_ptr)(ARGS...);
    return std::function<R(ARGS...)>((func_ptr)fp);
}
};

Кроме того, вы можете воспользоваться тем фактом, что std:: function может указывать на любой вызываемый объект, сделав свой указатель на функцию вызываемым (добавьте оператор()), который будет очень похож на преобразование в std:: function.

template<class Ret, class... Args> Ret operator()(Args... args)
{
     std::function<Ret(Args...)> f = *(reinterpret_cast<std::function<Ret(Args...)>*>(fp));
     return f(args...);
}