Declaring Function Pointer Variables

What is a Function Pointer?

In C, everything in a running program has a memory address. You're familiar with variables having addresses in the data, stack, or heap segments. Functions are no different. The compiled machine code instructions for a function reside in a read-only area of memory called the code segment (or text segment). The name of a function, in essence, acts as a label for the starting address of its first instruction.

A function pointer is simply a special type of pointer variable designed to hold the memory address of a function. Instead of pointing to data, it points to executable code.

This concept is explained very clearly in the following video.

By storing a function's address in a pointer, you can call that function indirectly through the pointer. This allows you to decide at runtime which function to execute, a technique that is fundamental for creating flexible and extensible software, such as implementing callbacks in communication middleware or building state machines.

The Declaration Syntax

Declaring a function pointer requires specifying three things:

1. The return type of the function it can point to.
2. The name of the pointer variable itself.
3. The parameter types of the function it can point to.

This is often called the function pointer's signature. A function pointer can only point to functions that have a matching signature.

The general syntax looks like this:

return_type (*pointer_name)(parameter_types);

Let's break this down with a practical reading exercise.

So, for a function with the prototype int add(int a, int b);, a corresponding function pointer named pfn_add would be declared as:

int (*pfn_add)(int, int);

• int: This is the return type.
• (*pfn_add): This declares pfn_add as a pointer. The parentheses are crucial.
• (int, int): These are the parameter types.

The "Inside-Out" Rule and The Importance of Parentheses

The syntax int (*pfn_add)(int, int); can be confusing. A helpful way to parse complex C declarations is the "inside-out" or "right-left" rule. You start with the variable name and work your way out.

Applying this to int (*pfn_add)(int, int);:

1. Start with the name: pfn_add...
2. Look right: nothing until ). Look left: *. So, "...is a pointer..."
3. Move outside the parentheses. Look right: (int, int). So, "...to a function that takes (int, int)..."
4. Look left: int. So, "...and returns an int."

Putting it together: pfn_add is a pointer to a function that takes (int, int) and returns an int.

The parentheses around (*pfn_add) are mandatory and non-negotiable. Without them, the compiler's precedence rules change the meaning entirely.

Compare these two declarations:

• int (*p)(int, int); // p is a pointer to a function.
• int *p(int, int); // p is a function that returns a pointer to an int.

This critical distinction is a common source of bugs. The following video segment highlights this and other syntax details.

As you saw, a function pointer is strongly typed. Attempting to assign a function with a mismatched signature will result in a compile-time error, a safety feature that is essential in the kind of high-integrity systems you build. This aligns with the principles of MISRA-C, which heavily restricts incompatible pointer type conversions.

A Brief Look at Usage

While our focus today is on declaration, it's helpful to see how these pointers are assigned and used. This will be the main topic of our next lesson.

You assign the address of a function to a pointer by using the function's name. The & operator is optional, as a function's name decays to its address in this context.

// Function prototype
void PrintMessage(const char* msg);

// Function pointer declaration
void (*p_print)(const char*);

// Assignment
p_print = PrintMessage; // The name 'PrintMessage' provides the address
// OR
p_print = &PrintMessage; // Explicitly taking the address also works

A common mistake is to accidentally call the function during assignment.

Once assigned, you can call the function through the pointer. Again, there are two equivalent syntaxes:

// Calling the function
p_print("Hello from a function pointer!"); // Implicit dereference (more common)
(*p_print)("Hello again!");              // Explicit dereference

Conclusion

In this lesson, we've focused on the foundational syntax for working with function pointers. Mastering this notation is the first and most critical step toward using them effectively.

Key Takeaways:

• A function pointer is a variable that stores the memory address of a function.
• Functions reside in the code segment of memory, and their names act as labels for their starting addresses.
• The declaration syntax is return_type (*pointer_name)(parameter_types);.
• The parentheses around (*pointer_name) are mandatory to distinguish a function pointer declaration from a function prototype that returns a pointer.
• A function pointer's signature (return type and parameter types) must exactly match the signature of any function it points to, ensuring type safety.

Preview of the Next Lesson:
Now that you can correctly declare a function pointer, our next lesson will dive deeper into assigning function addresses and invoking functions through them. We will explore practical examples of how to swap which function gets called at runtime, laying the groundwork for implementing powerful patterns like callbacks.