c ++作为没有指针的参数

Question

When searching for how to pass functions as parameters in C++, I only find examples that use function pointers. However the following compiles and outputs "g20" as expected in Visual Studio. Is it better to declare f like this:

f(void (*fun)());

instead of

f(void fun());

my example:

#include <iostream>

using namespace std;

int f(void fun());
void g();

int main() {
    cout << f(g);
}

void g() {
    cout << "g";
}

int f(void fun()) {
    fun();
    return 20;
}

Answer 1

You might prefer std::function<> instead of function pointers. It can not only store function pointers, but also lambdas, bind expressions, function objects (objects with operator() ), etc. Especially the lambdas will make your API a lot better usable.

int f(std::function<void()>& fun) {
    fun();
    return 20;
}

Answer 2

Another way which is simple and does not have the cost of a std:::function is to use templates.

template <typename Function>
int f(Function function) {
  function();
  return 20;
}

That way the type will be deduced to be any kind of callable object. It should also enable the compiler to inline the call if it can (which is not possible with std::function ).

Answer 3

Both forms are equivalent. I prefer the form which explicitly shows that the parameter is a pointer. The knowledge, that the parameter is a pointer is important, since you can pass the values NULL , nullptr or 0 as argument. Your program would compile, but crash if someone would do the function call f(0) . You always want to check if a function pointer is not a null pointer before calling the pointee, unless you are certain that it is not possible that your function is called with a NULL , nullptr or 0 argument.

If you use lambdas in your project, you should use `templates. Otherwise you can continue to use raw function pointers, but make sure that you check your function pointer (if necessary)

template <typename Function>
int f(const Function& functionp) {
  if(functionp)
     functionp();
  return 20;
}

Lambdas and std::function<> objects also have a bool operator, so the line if(functionp) will also work for those. It will evaluate to false for std::function<> objects which contain a nullptr and otherwise it will evaluate to true for std::function<> objects and lambdas.

Answer 4

Ampersand & makes it a reference, std::decay_t makes reference a pointer.

template <class R, class Args...>
using func_ref_t = R(&)(Args...)

template <class R, class Args...>
using func_ptr_t = R(&)(Args...)

Answer 5

According to the C (and C++) standard, when a parameter has a function type, the compiler automatically adjusts it to the corresponding function pointer type. Therefore, the two are identical as far as the compiler is concerned.

C99 standard section 6.7.5.3 paragraph 8:

A declaration of a parameter as ''function returning type'' shall be adjusted to ''pointer to function returning type'', as in 6.3.2.1.

C++03 standard section 8.3.5 paragraph 3:

[...] After determining the type of each parameter, any parameter of type [...] “function returning T” is adjusted to be [...] “pointer to function returning T,” respectively. [...]