5

I know when we use the name of a function as a value, the function is automatically converted to a pointer. look at following code:

int print(int a)
{
    return a;
}

int main()
{
    int (*p)(int) = print;
    int (*q)(int) = &print;

    cout << p(8) << endl;
    cout << (*p)(8) << endl;
}

why are int (*p)(int) = print; , print is a pointer, and int (*p)(int) = &print;, &print is an address to a pointer, equivalent?

On the other hand, when we use a pointer to a function to call the function, why are p(8) and (*p)(8) equivalent?

3
  • I guess it is just for convenience, that you dont have to explicitly dereference function pointers when using them to call the function. If you use typedefs you can work with function pointer without using any * which imho is quite nice Commented Nov 4, 2015 at 14:58
  • 2
    Possible duplicate of How does dereferencing of a function pointer happen? Commented Nov 4, 2015 at 15:04
  • @SimonKraemer thank you. But the link only explain the dereference, my question also include the assignment of function pointer. Commented Nov 4, 2015 at 15:18

2 Answers 2

3

print is not a pointer. Its type is int(int), not int(*)(int). This distinction is especially important in type deduction

auto& f = print;   //type of f is int(&)(int), not int(*(&))(int)
template<typename Func>
foo(Func& f);
foo(print);  //Func is deduced to be int(int), not int(*)(int)

Analogous to arrays, you cannot copy a function "by value", but you can pass around its address. For example,

int arr[4];     //the type of arr is int[4], not int*
int *a = arr;   //automatic array-to-pointer decay
int (*a)[4] = &arr;  //type match 
int (*p)(int) = print;  //automatic function-to-pointer decay
int (*p)(int) = &print; //type match

Now when you call print through p,

p(8)     //automatic dereferencing of p
(*p)(8)  //manual dereferencing of p
Sign up to request clarification or add additional context in comments.

2 Comments

your answer make some sense. but in the book c++ primer 5th edition and many other website tutorial said using function name as rvalue will convert it to a pointer. So I don't know whether your answer is a special condition for function pointer assignment.
@sydridgm They are correct. And they are referring to the function-to-pointer decay in my answer.
2

print is a function, but it is implicitly convertible to a function pointer type. Quoted from cppref:

Function to pointer
An lvalue of function type T can be implicitly converted to a prvalue pointer to that function. This does not apply to non-static member functions because lvalues that refer to non-static member functions do not exist.

So, in your case:

int (*p)(int) = print; // Conversion happens.
int (*q)(int) = &print; // Conversion does not happen.

Implicit conversion kicks in automatically when it is needed to make the program compile, and is not applied otherwise.

With respect to function calling, it is about the built-in function call operator (). According to cppref, the built-in function call operator is applicable to both an lvalue expression that refers to a function and a pointer to function. In your case:

p(8); // The function call operator is applied to a pointer to function.
(*p)(8); // The function call operator is applied to an lvalue reference to function.

For your reference (emphasis mine):

Built-in function call operator
A function call expression, such as E(A1, A2, A3), consists of an expression that names the function, E, followed by a possibly empty list of expressions A1, A2, A3, ..., in parentheses. The expression that names the function can be

a) lvalue expression that refers to a function
b) pointer to function
...

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.