## Tag Archives: function

Simple example

```
f := (x) -> x^2

```

Is the function f(x)=x^2. You call it by writing

```
f(2)

```

To animate the function, just add another parameter and give it a range in a plot command.

```
plot( a*f(x), x=-2..2, a=0.1..5 )

```

# Function pointer syntax tutorial

Function pointer syntax is one of those weird, weird things that just doesn’t seem right.

```double (*fun)(int,int,double*)
```

In less than 2 paragraphs, you will!

First things first. What is a function pointer anyway? Why, its simply a variable that, instead of pointing to an object (like an `int*` will point to an integer, and a `double*` will point to a double), this weird, weird “function pointer” will actually point to __A FUNCTION__!!

WHAT?? You say. POINT TO A FUNCTION! Why, yes! It is no different than me pointing to a recipe. Its one thing to have a copy of the recipe for chocolate mousse in hand (an actual function body), and its another thing to have a hyperlink that merely __points__ to that chocolate mousse recipe (a pointer to the function). When you have a pointer to a function (hyperlink to a recipe) you can still execute it (make the recipe) but you need to remember to dereference the pointer first (follow the hyperlink to pull up the recipe).

Does that make a little bit of sense? Me hopes so.

Moving on to function pointer syntax then, it is actually not that bad to read. Say you had a function:

```void SayIt()
{
puts( "It. There.  Happy now?" ) ;
}
```

And you wanted to declare a function pointer to the SayIt() function in your main function:

```int main()
{
// DECLARE A FUNCTION POINTER TO THE
// SayIt() function by the name of ptrSayIt
void (*ptrSayIt)() ;
// The above is probably the weirdest, non-C++ish
// syntax you've come across.  It looks weird because
// it is.  No, really, function pointer declaration
// syntax is kind of mixed up.
// 1.  First, the word VOID specifies the
// return type of the function that you
// will point to...
// 2.  Second is (*ptrSayIt).  The bracket
// and star combination (* there
// says THIS IS A FUNCTION POINTER, NOT
// A FUNCTION DECLARATION THAT RETURNS A POINTER
// TO VOID* (which is what "void *ptrSayIt();" would mean!)
// 3.  Third, the trailing brackets at the end ()
// say that the function we are pointing to
// won't accept any arguments when it is called.

// If it helps, you can look at it as:
// void(*)().  That is the type of the
// ptrSayIt variable.  The "mixed up" part
// is because this breaks the usual C declaration
// syntax of TYPE    InstanceName,
// and so its really weird to look at at first.
// Then you kind of get used to it.  Keep reading!

// Now the ptrSayIt variable points to the
// SayIt function..
ptrSayIt = &SayIt ; // you don't really need the & in front
// but I put it to be clear

// Now we can call the SayIt function __through__
// the ptrSayIt pointer we just declared and set up!
(*ptrSayIt)() ; // (*DEREFERENCE) the pointer first!
// OUTPUTS:  "It.  There.  Happy now?"
// TRY IT YOURSELF!
}
```

So this all seems very weird. But the program above works, I guarantee!

Lets do some more examples.

Declare a function pointer named Foo that points to a function marked by prototype:

```int add( int a, int b ) ;
```

```int (*Foo)(int,int) ;
```

Reasoning: the return type of the function you are about to point to goes first.

```int        // function pointer will point
// to a function returning int..
```

Then, you do this mixed up thing where you write the name of the pointer variable NOW, in brackets, with a * in front:

```int (*Foo) // function pointer VARIABLE
// identifier/handle is Foo.  This is actually
// the WEIRDEST part of the syntax.
```

Then you follow up with the types of arguments that the function you are trying to point to will contain:

```int (*Foo)( int, int )   // will point
// to a function accepting 2 ints
```