XQA
Back to C Programming
2026-03-306 min read

function-like macro invocation

Learn function-like macro invocation step by step with clear examples and exercises.

Why This Matters

Function-like macros are an essential part of C programming, offering a way to create custom functions using preprocessor directives. They allow for the creation of reusable code that can perform complex operations, making your programs more modular and easier to maintain. Understanding function-like macros is crucial when dealing with low-level programming tasks or optimizing performance.

By mastering function-like macros, you'll be able to write concise and efficient code, reducing the number of functions required in your projects. This can lead to smaller binary sizes, faster compilation times, and improved maintainability.

Prerequisites

Before diving into function-like macros, it is essential to have a good understanding of:

  1. Basic C syntax and semantics
  2. Preprocessor directives (#include, #define, etc.)
  3. Variable arguments (va_list, va_start, va_arg)
  4. Understanding the difference between object-like and function-like macros
  5. Familiarity with control structures such as loops and conditional statements
  6. Adequate understanding of data types, variables, and functions in C programming
  7. Knowledge of operator precedence and associativity rules
  8. Comfortable with using debugging tools to identify issues related to macro expansion

Core Concept

Function-like macros are defined using the #define preprocessor directive with a prototype-like syntax, similar to a regular C function. They can take arguments and return values, making them behave like functions during the compilation process.

#define my_function(a, b) ((a) * (b))
int main() {
int result = my_function(3, 4); // expands to: ((3) * (4))
printf("Result: %d\n", result); // Output: Result: 12
}

In the above example, my_function is a function-like macro that multiplies its two arguments. The parentheses around the arguments and the return type are essential to ensure correct evaluation order and return type.

Function-Like Macro Prototype

A function-like macro prototype consists of:

  1. The macro name (e.g., my_function)
  2. A list of parameters enclosed in parentheses, separated by commas (e.g., (a, b))
  3. An empty set of parentheses if the macro has a return type (e.g., ())
  4. The macro body

Macro Expansion

When the preprocessor encounters a function-like macro call, it replaces the call with the corresponding macro definition, expanding the macro body with the actual arguments provided in the call. This process continues recursively until all macros have been expanded or until there are no more macro calls left to expand.

Macro Expansion Order

Note that that macro expansions occur before any other C constructs, including control structures and function calls. This can lead to unexpected results if not managed carefully. For example:

#define SQUARE(x) x * x
int main() {
int a = 3;
int b = SQUARE(a++); // expands to: a++ * a++, causing incorrect result due to post-increment
printf("Result: %d\n", b); // Output: Result: 16 (incorrect)
}

To avoid such issues, use parentheses around the arguments and be mindful of operator precedence and associativity rules.

Worked Example

Let's create a function-like macro for swapping two variables without using a temporary variable.

#define SWAP(type, x, y) do { type temp = (x); (x) = (y); (y) = temp; } while (0)

int main() {
int a = 5, b = 10;
printf("Before swap: a=%d, b=%d\n", a, b);
SWAP(int, a, b);
printf("After swap: a=%d, b=%d\n", a, b); // Output: Before swap: a=5, b=10; After swap: a=10, b=5
}

In the above example, SWAP is a function-like macro that swaps two variables of any type. The do { ... } while (0) construct prevents the preprocessor from expanding the macro multiple times during the evaluation process.

Macro Expansion with SWAP

  1. SWAP(int, a, b); expands to: do { int temp = a; a = b; b = temp; } while (0)
  2. a = b; expands to: b = a;
  3. b = a; expands to: a = b;
  4. The final expansion is the swapped values of a and b.

Common Mistakes

  1. Omitting parentheses: Failure to include parentheses around the arguments can lead to incorrect evaluation order or wrong results.
// Incorrect: my_function expands to: a * b, not (a) * (b)
#define my_function a * b
int result = my_function(3, 4); // Output: Result: 12 (incorrect)
  1. Ignoring return type: Not specifying the return type of the macro can lead to compilation errors when using the macro in expressions with different types.
// Incorrect: my_function has no specified return type
#define my_function a + b
int result = my_function(3, 4); // Compilation error: invalid operands to binary operator (+)
  1. Macro recursion: Incorrectly using recursive macros can lead to infinite loops or stack overflow errors.
// Incorrect: recursive macro with no base case
#define RECURSIVE(n) n + RECURSIVE(n - 1)
int main() {
int result = RECURSIVE(5); // Stack overflow error
}
  1. Macro expansion order: Macros can be expanded in unexpected ways when they are nested or depend on other macros, leading to incorrect results.
// Incorrect: macro expansion order issue
#define A 1
#define B A + 2
#define C A * 3
#define D A + B
#define E A * C
int main() {
int result = D + E; // Output: Result: 16 (incorrect)
}
  1. Macro and function naming collisions: Using the same name for a macro and a function can lead to unexpected behavior, as the macro will take precedence during preprocessing.
// Incorrect: macro and function have the same name
void myFunction(int x) { printf("Function called with %d\n", x); }
#define myFunction(x) (x * x)
int main() {
int result = myFunction(3); // Outputs: 9, not "Function called with 3"
}

Practice Questions

  1. Write a function-like macro for finding the factorial of a number using recursion.
  2. Implement a function-like macro that calculates the maximum of two numbers without using if statements or conditional operators.
  3. Create a function-like macro that swaps two pointers to integers without using temporary variables.
  4. Write a function-like macro for finding the greatest common divisor (GCD) of two numbers using Euclid's algorithm.
  5. Implement a function-like macro for computing the Fibonacci sequence up to a given number n.
  6. Create a function-like macro that calculates the sum of all digits in an integer without using loops or recursion.
  7. Write a function-like macro that checks if a given number is prime.
  8. Implement a function-like macro for finding the square root of a number using Newton's method.
  9. Create a function-like macro that generates all permutations of a given array.
  10. Write a function-like macro for sorting an array using bubble sort algorithm.

FAQ

  1. Why can't I use function-like macros for recursive functions?

Function-like macros cannot handle recursion correctly because they are expanded during the preprocessing phase, not during runtime. Recursive function calls create a new scope each time, which is not supported by macros.

  1. Can I use function-like macros for complex mathematical operations?

Yes, you can use function-like macros for simple and complex mathematical operations. However, it's essential to be careful with the evaluation order and return types to avoid errors.

  1. What are some best practices when using function-like macros?

Some best practices include:

  • Using parentheses around arguments
  • Specifying the return type of the macro
  • Avoiding recursive macros or using them carefully with a base case
  • Being mindful of macro expansion order and dependencies
  • Using do { ... } while (0) to prevent multiple expansions during evaluation
  1. What is the difference between object-like and function-like macros?

Object-like macros are used to create constant or variable objects, while function-like macros behave like functions, taking arguments and returning values. Object-like macros do not have a prototype-like syntax and are typically used for defining constants or type aliases.