Macro with arguments - Step-by-Step Execution

Concept Flow - Macro with arguments

Define macro with args

↓

Use macro in code

↓

Preprocessor replaces macro call

↓

Code compiles with replaced text

↓

Program runs with macro effect

A macro with arguments is defined and then used in code; the preprocessor replaces the macro call with the expanded code before compilation.

Execution Sample

C

#define SQUARE(x) ((x) * (x))
int main() {
  int a = 5;
  int b = SQUARE(a);
  return b;
}

This code defines a macro SQUARE that calculates the square of a number and uses it to compute b = 25.

Execution Table

Step	Code Line	Macro Expansion	Variable Values	Action
1	#define SQUARE(x) ((x) * (x))	Macro defined	-	Macro SQUARE with argument x is defined
2	int a = 5;	-	a=5	Variable a initialized to 5
3	int b = SQUARE(a);	int b = ((a) * (a));	a=5, b=25	Macro call replaced by ((a) * (a)), b computed as 25
4	return b;	-	b=25	Return value is 25
5	Program ends	-	-	Program ends with return 25

💡 Program ends after returning b=25, macro expansion done before compilation

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
a	undefined	5	5	5
b	undefined	undefined	25	25

Key Moments - 2 Insights

Why does the macro use extra parentheses around (x) and the whole expression?

Parentheses ensure correct order of operations when the macro argument is an expression; see Step 3 where ((a) * (a)) prevents errors if x is complex.

Is the macro a function? Does it evaluate its argument multiple times?

No, it's a text replacement done before compilation. The argument x is repeated twice in the expansion, so if x has side effects, it runs twice. See Step 3 macro expansion.

Visual Quiz - 3 Questions

Look at the execution table at Step 3, what is the value of b after macro expansion?

A 5

B 25

C 10

D Undefined

💡 Hint

Check the 'Variable Values' column at Step 3 in the execution table

At which step is the macro SQUARE actually replaced by its code?

A Step 3

B Step 2

C Step 1

D Step 4

💡 Hint

Look at the 'Macro Expansion' column to see where replacement happens

If we change the macro to #define SQUARE(x) (x * x) without parentheses, what problem might occur?

A No problem, works same

B Compilation error

C Wrong calculation if x is an expression like a+1

D Macro won't expand

💡 Hint

Think about operator precedence and how parentheses affect the expanded code

Concept Snapshot

#define MACRO_NAME(args) replacement
Macro with arguments replaces calls with code using those args.
Use parentheses around args and whole expression to avoid errors.
Macro is text substitution done before compilation.
Beware: arguments may be evaluated multiple times.

Full Transcript

This example shows how a macro with arguments works in C. First, the macro SQUARE is defined to compute the square of a value. When the program runs, the macro call SQUARE(a) is replaced by ((a) * (a)) before compilation. Variable a is set to 5, then b is assigned the result of the macro expansion, which is 25. The program returns 25. Parentheses in the macro ensure correct calculation even if the argument is complex. The macro is not a function; it is a text replacement, so arguments can be evaluated multiple times if used more than once in the macro body.

Practice

1. What does a macro with arguments in C do?

easy

A. It replaces code snippets with given values before compilation

B. It creates a new function at runtime

C. It allocates memory dynamically

D. It executes code conditionally during runtime

Solution

1. Step 1: Understand macro replacement

   Macros with arguments are replaced by the preprocessor before the program runs, substituting the macro call with the code snippet using the given arguments.

2. Step 2: Differentiate from functions

   Unlike functions, macros do not create executable code at runtime but perform textual substitution during compilation.

3. Final Answer:

   It replaces code snippets with given values before compilation -> Option A

4. Quick Check:

   Macro = code substitution before compile [OK]

Hint: Macros replace code before running, not at runtime [OK]

Common Mistakes:

• Thinking macros create functions
• Confusing macros with runtime code
• Assuming macros allocate memory

2. Which of the following is the correct syntax for defining a macro with two arguments a and b that adds them?

easy

A. #define ADD(a, b) a + b

B. #define ADD a, b (a + b)

C. #define ADD(a, b) (a + b)

D. #define ADD(a, b) {a + b}

Solution

1. Step 1: Check macro argument syntax

   Macro arguments must be enclosed in parentheses immediately after the macro name, like ADD(a, b).

2. Step 2: Ensure proper expression grouping

   To avoid operator precedence issues, the expression should be enclosed in parentheses: (a + b).

3. Final Answer:

   #define ADD(a, b) (a + b) -> Option C

4. Quick Check:

   Correct macro syntax = #define NAME(args) (expression) [OK]

Hint: Always put parentheses around macro arguments and whole expression [OK]

Common Mistakes:

• Missing parentheses around arguments
• Not enclosing expression in parentheses
• Using braces {} instead of parentheses

3. Given the macro definition #define SQUARE(x) x * x, what is the output of printf("%d", SQUARE(3 + 1));?

medium

A. Error

B. 16

C. 12

D. 7

Solution

1. Step 1: Expand the macro with argument

   The macro call SQUARE(3 + 1) expands to 3 + 1 * 3 + 1 because the macro definition lacks parentheses around the expression.

2. Step 2: Apply operator precedence

   Multiplication has higher precedence, so 3 + (1 * 3) + 1 = 3 + 3 + 1 = 7.

3. Final Answer:

   7 -> Option D

4. Quick Check:

   Without parentheses, macro expands incorrectly = 7 [OK]

Hint: Without parentheses, macro args can cause wrong math [OK]

Common Mistakes:

• Assuming macro adds parentheses automatically
• Ignoring operator precedence
• Expecting 16 as square of 4

4. Identify the error in this macro definition: #define MULTIPLY(a, b) a * b)

medium

A. Extra closing parenthesis at the end

B. Missing opening parenthesis before a

C. Arguments should not have parentheses

D. Macro name should be lowercase

Solution

1. Step 1: Check parentheses balance

   The macro ends with an extra closing parenthesis ")" that does not match any opening parenthesis.

2. Step 2: Confirm correct macro syntax

   Macro should be defined as #define MULTIPLY(a, b) (a * b) with balanced parentheses around the expression.

3. Final Answer:

   Extra closing parenthesis at the end -> Option A

4. Quick Check:

   Parentheses must be balanced in macro definitions [OK]

Hint: Count parentheses carefully in macro definitions [OK]

Common Mistakes:

• Ignoring unmatched parentheses
• Thinking arguments can't have parentheses
• Believing macro names must be lowercase

5. You want to create a macro MAX(a, b) that returns the larger of two values. Which definition correctly handles expressions as arguments without errors?

hard

A. #define MAX(a, b) ((a > b) ? a : b)

B. #define MAX(a, b) ((a) > (b) ? (a) : (b))

C. #define MAX(a, b) a > b ? a : b

D. #define MAX(a, b) (a > b ? a : b)

Solution

1. Step 1: Understand argument safety

   To safely handle expressions as arguments, each argument must be enclosed in parentheses to avoid precedence errors.

2. Step 2: Check full macro expression grouping

   The entire conditional expression should be enclosed in parentheses to ensure correct evaluation when used in larger expressions.

3. Final Answer:

   #define MAX(a, b) ((a) > (b) ? (a) : (b)) -> Option B

4. Quick Check:

   Parentheses around args and whole expression prevent bugs [OK]

Hint: Always parenthesize macro args and whole expression [OK]

Common Mistakes:

• Missing parentheses around arguments
• Not enclosing entire expression
• Assuming macro works like a function