Passing Functions as Arguments

Part of the Object Oriented Programming section of Coddy's C journey — lesson 36 of 61.

One of the most powerful uses of function pointers is passing them as arguments to other functions. This allows you to inject custom behavior into a function without modifying its code — a technique sometimes called a callback.

Consider a function that performs a calculation on two numbers. Instead of hardcoding the operation, you can accept a function pointer that defines what operation to perform:

typedef int (*Operation)(int, int);

int compute(int a, int b, Operation op) {
    return op(a, b);
}

The compute function doesn't know whether it's adding, subtracting, or doing something else entirely. It simply calls whatever function is passed to it:

int add(int a, int b) { return a + b; }
int multiply(int a, int b) { return a * b; }

int main() {
    printf("%d\n", compute(5, 3, add));       // Output: 8
    printf("%d\n", compute(5, 3, multiply));  // Output: 15
    return 0;
}

Notice how the same compute function produces different results based on which function we pass. This pattern is fundamental to writing flexible, reusable code — you write the structure once, and users of your function supply the specific logic they need.

Challenge

Easy

Write a function apply_twice that takes two integers and an operation code, applies the operation to the numbers twice in sequence, and returns the final result.

Your function will receive an operation code that determines which operation to use. You must define the operation functions inside your solution and pass them to a helper compute function that accepts a function pointer.

Required structure:

Define a typedef called Operation for a function pointer that takes two int parameters and returns an int
Define two operation functions: add (returns a + b) and multiply (returns a * b)
Define a compute function that takes two integers and an Operation function pointer, then returns the result of calling the operation
In apply_twice, select the appropriate operation based on the code, then use compute twice: first with the original numbers, then with the result and the second number again

Logic:

Select the operation function based on op_code (1 = add, 2 = multiply)
Call compute(a, b, operation) to get an intermediate result
Call compute(intermediate, b, operation) to get the final result
Return the final result

Parameters:

a (int): First number
b (int): Second number
op_code (int): Operation code (1 for add, 2 for multiply)

Returns: The result after applying the operation twice in sequence (int)

Example: With a = 5, b = 3, op_code = 1 (add):

First compute: 5 + 3 = 8
Second compute: 8 + 3 = 11
Return: 11

With a = 2, b = 4, op_code = 2 (multiply):

First compute: 2 × 4 = 8
Second compute: 8 × 4 = 32
Return: 32

Cheat sheet

Function pointers can be passed as arguments to other functions, enabling callbacks — a way to inject custom behavior without modifying the function's code.

Define a function pointer type using typedef:

typedef int (*Operation)(int, int);

Create a function that accepts a function pointer as a parameter:

int compute(int a, int b, Operation op) {
    return op(a, b);
}

Pass different functions to achieve different behaviors:

int add(int a, int b) { return a + b; }
int multiply(int a, int b) { return a * b; }

int main() {
    printf("%d\n", compute(5, 3, add));       // Output: 8
    printf("%d\n", compute(5, 3, multiply));  // Output: 15
    return 0;
}

This pattern allows you to write flexible, reusable code where the structure is defined once and users supply the specific logic they need.

Try it yourself

int apply_twice(int a, int b, int op_code) {
    // Write code here
}

Test yourself

This lesson includes a short quiz. Start the lesson to answer it and track your progress.

All lessons in Object Oriented Programming

1Modular Programming Basics

Header Files Include Guards Source Files Static Functions Recap: Modular Calculator

4Encapsulation

Opaque Pointers Concept Defining Opaque Structs Getters and Setters Validation in Setters Recap: Secret Box

7Function Pointers

Declaring Function Pointers Calling Function Pointers Typedef for Function PointersPassing Functions as ArgumentsRecap: Calculator Dispatch

10Generic Containers

Void Pointers Recap Generic Wrapper Generic Swap Generic Compare Recap: Generic Array

2Objects and Methods

Structs as Objects The 'Self' Pointer Const Correctness Pointer vs Value Helper Methods Recap: Point Manager

5Project: Simple Bank Account

Project Setup Implementation of Account

Deposit Logic

Withdraw Logic

Get Balance

Project Finale: Main Loop

8Polymorphism

Function Pointers in Structs Simulating Methods The Interface Concept Implementing Interfaces Polymorphic Iteration Recap: Greeter

11Design Patterns in C

Singleton Pattern Factory Pattern Iterator Pattern Recap: Logger Factory

3Object Lifecycle

Constructor Pattern Destructor Pattern Stack Initialization Deep Copy Recap: String Wrapper

6Inheritance via Composition

Struct Embedding The First Member Rule Accessing Parent Members Upcasting Recap: Shape Hierarchy

9Project: Shape Drawer

Project Overview Circle Implementation

Rectangle Implementation

Polymorphic Usage

Shape Container

12Final Challenges

RPG Character Dynamic String Builder Generic Stack Event System