Reusability and maintenance - Mini Project: Build & Apply

Reusability and maintenance

📖 Scenario: You are working on a small program that calculates the area of different shapes. To keep your code clean and easy to maintain, you want to reuse the area calculation logic by putting it inside functions.

🎯 Goal: Create reusable functions to calculate the area of a rectangle and a circle, then use these functions to print the areas for given dimensions.

📋 What You'll Learn

Create a function called rectangle_area that takes two double parameters length and width and returns their product as double.

Create a function called circle_area that takes one double parameter radius and returns the area of the circle using the formula 3.14159 * radius * radius.

In main, declare variables rect_length and rect_width with values 5.0 and 3.0 respectively.

In main, declare a variable circle_radius with value 2.0.

Call the functions rectangle_area and circle_area with the declared variables and print the results with descriptive text.

💡 Why This Matters

🌍 Real World

Reusable functions are used in real software to avoid repeating code and to make programs easier to update and fix.

💼 Career

Understanding how to write and use functions is essential for any programming job, as it improves code quality and teamwork.

1

Create variables for rectangle and circle dimensions

In the main function, create double variables called rect_length and rect_width and set them to 5.0 and 3.0 respectively. Also create a double variable called circle_radius and set it to 2.0.

C

#include 

int main() {
    // Create double variables rect_length, rect_width, and circle_radius with values 5.0, 3.0, and 2.0
    // Your code here
    return 0;
}

Hint

Use the syntax double variable_name = value; to create each variable.

2

Create function to calculate rectangle area

Above the main function, create a function called rectangle_area that takes two double parameters named length and width. The function should return a double which is the product of length and width.

C

#include 

// Create function rectangle_area with parameters length and width
// Your code here

int main() {
    double rect_length = 5.0;
    double rect_width = 3.0;
    double circle_radius = 2.0;
    return 0;
}

Hint

Define the function with double return type and multiply the two parameters.

3

Create function to calculate circle area

Above the main function, create a function called circle_area that takes one double parameter named radius. The function should return a double which is the area calculated as 3.14159 * radius * radius.

C

#include 

double rectangle_area(double length, double width) {
    return length * width;
}

// Create function circle_area with parameter radius
// Your code here

int main() {
    double rect_length = 5.0;
    double rect_width = 3.0;
    double circle_radius = 2.0;
    return 0;
}

Hint

Use the formula for circle area and return the result.

4

Call functions and print the areas

In the main function, call rectangle_area with rect_length and rect_width and store the result in a double variable called rect_area. Call circle_area with circle_radius and store the result in a double variable called circ_area. Then print both areas using printf with the exact text:
"Rectangle area: %f\n" and "Circle area: %f\n".

C

#include 

double rectangle_area(double length, double width) {
    return length * width;
}

double circle_area(double radius) {
    return 3.14159 * radius * radius;
}

int main() {
    double rect_length = 5.0;
    double rect_width = 3.0;
    double circle_radius = 2.0;
    // Call rectangle_area and circle_area, store results in rect_area and circ_area
    // Print the areas with printf
    // Your code here
    return 0;
}

Hint

Use printf("Rectangle area: %f\n", rect_area); and similarly for circle area.

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