Function Pointers on "C++ Primer Plus" Confusing Me

[MienTommy]

Here is what is confusing me:

const double * f1(const double ar[], int n);
const double (*f2)(const double ar[], int n);
const double f3(const double ar[], int n);

What is the difference between the first and second function?

From my eyes, the first function(f1) is a function that returns a pointer of type double with the function name of f1.
The second function(f2) returns type double and I have no idea what (*f2) in this definition.
The third function is just a regular function returning type double with the name of f3.

const double *(*p1)(const double *, int) = f1;
I am just mind boggled of how this looks. I can see that "const double *" represents that it is a pointer of type double, but the name (*p1) yet again confuses me. I know in the end though that all it does is point to f1, I just don't understand how it looks.

[vlad from moscow]

This

const double (*f2)(const double ar[], int n);

is a definition of pointer to function that has return type const double and has two parameters of type const double [] and int.

This

const double *(*p1)(const double *, int) = f1;

is a definition of pointer to function that has return type const double * and has the same parameters as in the definition above. This pointer is initialized by the address of the function f1.

[MienTommy]

Okay so I made a function:

const int * add(int a, int b)
{
	int * ptr = new int (a + b);
	return ptr;
}

The program compiles but logically, would this be valid? Since in this example it returns a type int * instead of a const int *?

[vlad from moscow]

I have not understood how this question is related with the previous question.
As for this function definition I do not see any sense to return const int * do not seeing the context where such a function can be used. So if to speak about the logical validity we should know relative which context it is logically valid.

[MienTommy]

What I meant was, I was just wondering(from my previous post) in the terms of "valid" that if I should be returning a int * or const int * because shouldn't the return value match the type definition?


Sorry about the relativity to the first question, I am currently learning about function pointers at the current moment and just a little confused about it especially the pointer to pointer parts.

I understand that const double *(*p1)(const double *, int) = f1; has a return value type of const double * but why is the * in p1 needed? What if I took it out? How would that be read to the C++ compiler? What would the C++ compiler think?

[vlad from moscow]

As i said it depends on the purpose of the function.
As for the C++ compiler then it does not think. It simply compiles your code.

[MienTommy]

Okay, well what would my compiler see that as, not in terms of sight, but logic, if I were to write the following code: const double * p1(const double *, int) saying I no longer want p1 to be a pointer.

With that code the compiler lets me compile it, but when I try to initialize it to something, it says "p1 may not be initialized". So what is happening there?

[vlad from moscow]

I have understood nothing. The compiler will say nothing. It simply will compile the function definition because it satisfies the C++ syntax.

EDIT: you may not to use the same identifies for an object and for a function name in the same declaration region. So the compiler will issue an error if p1 will be defined as a function pointer and a function name at the same time.

[JLBorges]

> const double *(*p1)(const double *, int) = f1;
> I am just mind boggled of how this looks. I can see that "const double *" represents that it is a ptr of type double,
> but the name (*p1) yet again confuses me.

Let us look at this from first principles.

int foo(double) ;

foo is a function which takes one parameter of type double and returns a value of type int.
foo has a type; it is 'unary function taking a parameter of type double and returning an int' or simply int(double)

int bar(double) ;

foo and bar are of the same type.

int* baz(double) ;
int *baz(double) ;
int * baz(double) ;

baz is also a function, but the type of baz is different; it is int*(double), it returns a pointer to int.
It does not matter how you place white space while writing baz, the * binds to the left.

Now, say, we wand to define a pointer to a function which can point to foo.
The type of the ptr that we need is 'pointer to int(double)'
ie. 'pointer to unary function taking a parameter of type double and returning an int'

This won't do at all: int *ptr(double) ;
Here, ptr is of the same type as baz; the * binds to the int; we might as well have written int* ptr(double) ;

Instead, we want the * to bind to ptr; to say that ptr is a pointer.

We can do this in two ways.

One, create a type alias for the type of the function foo:

typedef int type_of_foo(double) ;
using type_of_foo = int(double) ; // C++11
using type_of_foo = decltype(foo) ; // C++11 

type_of_foo is an alias, another name by which we can refer to int(double), the type of the function.

And now, we can write

type_of_foo* ptr = &foo ; // type of ptr is 'pointer to int(double)'

ptr is a pointer to a function, and it is initialized to point to foo.

ptr = &bar ; this too is fine, bar is a function of the same type, and ptr now points to bar.

The other (somewhat clumsier) way is to use parantheses to change the binding of the *

int (*ptr)(double) = &foo ; // type of ptr is 'pointer to int(double)'

Because of the paranthesis, the * binds to ptr and not to int.



> The program compiles but logically, would this be valid?
> Since in this example it returns a type int * instead of a const int *?

For an implicit conversion, a (top level) const qualifier may be added.
If T is some type, there is an implicit conversion from T* to const T*

int i = 7 ;
int* p = &i ;
const int* pc = p ; // fine, conversion adds the const qualifier 

However, a const qualifier can't be dropped implicitly.

p = pc ; // *** error, conversion requires dropping the const qualifier

[keskiverto]

Function pointer is a variable. It is not a function. The value that it holds is an address of a function. When one does have condition that determines what to do:

for ( size_t i = 0; i < Count; ++i )
{
  if ( test )
  {
    result = foo( i * 42.0 );
  }
  else
  {
    result = bar( i * 42.0 );
  }
}

One could rearrange code to:

if ( test )
{
  for ( size_t i = 0; i < Count; ++i )
  {
    result = foo( i * 42.0 );
  }
}
else
{
  for ( size_t i = 0; i < Count; ++i )
  {
    result = bar( i * 42.0 );
  }
}

Or, one could use a function pointer:

int (*ptr)(double) = test ? &foo : &bar;

for ( size_t i = 0; i < Count; ++i )
{
  result = ptr( i * 42.0 );
}

Callback can make use of function pointers. You can have a library code that you cannot change, but you should be able to customize it somehow, for the library cannot possibly know what you are up to. Therefore, the library function takes your function as function pointer and "calls back", i.e. executes your code.

Function pointers are standard C, but C++ has "classes" too that allow more ways to achieve similar things. Polymorphism and objects that behave like functions. Plenty of the C++ standard library algorithms accept function objects (aka functors). Callbacks.

[LB]

"C++ Primer Plus", you say? This book has a significantly bad review. Try "C++ Primer", which is by a different author and has a much better review.