4

In C++0x, we use use std::function like the following:

int normal_function() {
    return 42;
}
std::function<int()> f = normal_function;

So to get an std::function instance, we have to define its type firstly. But it's boring and sometimes hard.

So, can we just use make to get a std::function instance just like std::tuple?

In fact, I just googled, C++0x doesn't provide such make facility.

Why C++0x no provide make facility? Can we implement it?

Mat
  • 202,337
  • 40
  • 393
  • 406
Yuncy
  • 761
  • 1
  • 9
  • 20

1 Answers1

16

Yes we can implement it

template<typename T>
std::function<T> make_function(T *t) {
  return { t };
}

This requires that you pass a function to make_function. To prevent overload to pick this up for something other than a plain function, you can SFINAE it

template<typename T>
std::function<
  typename std::enable_if<std::is_function<T>::value, T>::type
> make_function(T *t) {
  return { t };
}

You cannot pass it class type function objects though and no member pointers. For arbitrary function objects there is no way to obtain a call signature (what would you do if the respective operator() is a template?). This probably is the reason that C++11 provides no such facility.

Johannes Schaub - litb
  • 496,577
  • 130
  • 894
  • 1,212
  • It'd probably be possible to extend to bind expressions and other such things where the type information follows a well known and standard structure. I've been wanting a wrapper that allowed me to pass in a `weak_ptr` to `mem_fn` and just have the call silently no-op if the `weak_ptr` was dead. – Omnifarious Dec 29 '11 at 17:35
  • You can use `std::mem_fn` to handle member function pointers. – quant_dev Apr 19 '14 at 18:27