Reusability and maintenance - Step-by-Step Execution

Concept Flow - Reusability and maintenance

Write reusable function

↓

Call function multiple times

↓

Change function code if needed

↓

All calls use updated code

↓

Easier to maintain and update

This flow shows how writing reusable functions helps call the same code many times and makes maintenance easier by updating one place.

Execution Sample

C

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

int main() {
    int sum = add(3, 4);
    return 0;
}

This code defines a reusable function 'add' and calls it to add two numbers.

Execution Table

Step	Action	Function Called	Parameters	Return Value	Notes
1	Define function 'add'	N/A	N/A	N/A	Function ready to use
2	Call 'add' from main	add	a=3, b=4	7	Function executes and returns sum
3	Store return value	N/A	N/A	7	Variable 'sum' gets value 7
4	Program ends	N/A	N/A	N/A	No more calls, program stops

💡 Program ends after main returns 0

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
a	N/A	3	N/A	N/A
b	N/A	4	N/A	N/A
sum	Undefined	Undefined	7	7

Key Moments - 2 Insights

Why do we write functions like 'add' instead of writing the addition code directly each time?

Because functions let us reuse code easily. As shown in step 2 and 3 of the execution_table, we call 'add' with different inputs without rewriting the addition logic.

If we want to change how addition works, do we need to change every place where addition is used?

No, only the 'add' function code needs to change. All calls use the updated function automatically, making maintenance easier (see concept_flow).

Visual Quiz - 3 Questions

Look at the execution_table, what is the return value when 'add' is called with parameters a=3 and b=4?

A 0

B 34

C 7

D Undefined

💡 Hint

Check row 2 in execution_table where 'add' is called with a=3 and b=4

At which step is the variable 'sum' assigned the value returned by 'add'?

A Step 2

B Step 3

C Step 1

D Step 4

💡 Hint

Look at execution_table row 3 where 'sum' gets the return value

If we change the 'add' function to subtract instead, what happens to the calls in main?

A They subtract numbers without changing main

B They still add numbers

C Main must be changed to subtract

D Program will not compile

💡 Hint

Refer to concept_flow showing maintenance by changing function code only

Concept Snapshot

Reusability and maintenance in C:
- Write functions to reuse code
- Call functions multiple times with different inputs
- Change function code once to update all calls
- Makes code easier to maintain and less error-prone
- Example: int add(int a, int b) { return a + b; }

Full Transcript

This example shows how writing reusable functions in C helps reuse code and maintain it easily. We define a function 'add' that takes two numbers and returns their sum. In main, we call 'add' with 3 and 4, and store the result in 'sum'. The execution table traces each step: defining the function, calling it, returning the value, and storing it. The variable tracker shows how 'a', 'b', and 'sum' change. Key moments explain why functions help reuse and maintain code. The quiz tests understanding of return values, variable assignment, and maintenance benefits. The snapshot summarizes the concept in short lines.

Practice

1. What is the main benefit of using functions in C for reusability and maintenance?

easy

A. Functions use less memory than variables

B. Functions make the program run faster

C. You can write code once and use it many times

D. Functions prevent all bugs automatically

Solution

1. Step 1: Understand the purpose of functions

   Functions allow you to group code that performs a task so you can reuse it multiple times without rewriting.

2. Step 2: Connect reusability to maintenance

   Using functions reduces repeated code, making it easier to update and maintain.

3. Final Answer:

   You can write code once and use it many times -> Option C

4. Quick Check:

   Functions improve reusability = You can write code once and use it many times [OK]

Hint: Functions let you reuse code easily [OK]

Common Mistakes:

• Thinking functions always make code faster
• Confusing functions with variables
• Believing functions fix all bugs automatically

2. Which of the following is the correct syntax to declare a function named add that takes two integers and returns an integer in C?

easy

A. int add(int a, int b);

B. add int(int a, int b);

C. int add(a, b) int a; int b; { return a + b; }

D. function add(int a, int b) { return a + b; }

Solution

1. Step 1: Identify correct function declaration syntax

   In C, a function declaration specifies the return type, function name, and parameter types inside parentheses.

2. Step 2: Check each option

   int add(int a, int b); matches the correct syntax: int add(int a, int b);. Others have wrong order, keywords, or syntax.

3. Final Answer:

   int add(int a, int b); -> Option A

4. Quick Check:

   Correct C function declaration = int add(int a, int b); [OK]

Hint: Function declarations start with return type and name [OK]

Common Mistakes:

• Using 'function' keyword (not in C)
• Wrong parameter syntax
• Missing return type

3. What will be the output of the following C code?

int square(int x) {
    return x * x;
}

int main() {
    int result = square(4);
    printf("%d", result);
    return 0;
}

medium

A. Compilation error

B. 8

C. 4

D. 16

Solution

1. Step 1: Understand the function behavior

   The function square returns the input multiplied by itself, so square(4) returns 16.

2. Step 2: Check the main function output

   The main function calls square(4), stores 16 in result, and prints it with printf.

3. Final Answer:

   16 -> Option D

4. Quick Check:

   square(4) = 16 [OK]

Hint: Multiply input by itself to find square [OK]

Common Mistakes:

• Confusing multiplication with addition
• Expecting 8 instead of 16
• Thinking code has syntax errors

4. Identify the error in the following C code that tries to reuse a function:

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

int main() {
    int result = multiply(5);
    printf("%d", result);
    return 0;
}

medium

A. multiply is called with only one argument instead of two

B. main function should return void

C. printf format specifier is incorrect

D. Function multiply is missing a return statement

Solution

1. Step 1: Check function definition and call

   The function multiply requires two integer arguments, but in main it is called with only one argument.

2. Step 2: Identify the error type

   This mismatch causes a compilation error because the number of arguments does not match the function signature.

3. Final Answer:

   multiply is called with only one argument instead of two -> Option A

4. Quick Check:

   Argument count mismatch = multiply is called with only one argument instead of two [OK]

Hint: Match function call arguments to definition [OK]

Common Mistakes:

• Ignoring argument count mismatch
• Thinking printf format is wrong
• Assuming main must return void

5. You want to write a reusable function in C that calculates the average of an array of integers. Which approach improves reusability and maintenance the most?

hard

A. Write the average calculation code inside main() every time you need it

B. Create a function that takes an integer array and its size, then returns the average

C. Use global variables to store the array and size, then write a function without parameters

D. Copy and paste the average calculation code wherever needed

Solution

1. Step 1: Understand reusability principles

   Reusable code should be modular, accept inputs, and avoid global state to be flexible and maintainable.

2. Step 2: Evaluate each option

   Create a function that takes an integer array and its size, then returns the average creates a function with parameters for array and size, making it reusable for any array. Others either duplicate code or rely on globals, reducing reusability.

3. Final Answer:

   Create a function that takes an integer array and its size, then returns the average -> Option B

4. Quick Check:

   Function with parameters improves reusability = Create a function that takes an integer array and its size, then returns the average [OK]

Hint: Functions with parameters are reusable and maintainable [OK]

Common Mistakes:

• Using global variables reduces flexibility
• Duplicating code increases errors
• Writing code only inside main limits reuse