Comprehensive Guide to C Language Functions: Overview and Definitions

<Overview and Definitions of Functions>From beginner to expert, from Hello World to ACMAll content, no textbooks required!

<Lecture>

1. Concept of Functions and Modular Programming

1.1 What is a Function?

The Essence of a Function: A function is a block of code that performs a specific task, capable of receiving input parameters, processing data, and returning results. You can think of a function as a “black box”—we only need to know what it does, without needing to care about how it is implemented internally.

Why Use Functions?

• Code Reusability: Avoid rewriting the same code

• Modularity: Break complex problems into smaller ones

• Maintainability: Modify functionality in one place only

• Team Collaboration: Different programmers can be responsible for different functions

1.2 The Concept of Modular Programming

Real-World Analogy: Just like car manufacturing, where different factories produce engines, tires, and bodies, which are then assembled into a complete vehicle.

Application in Programming:

// Code without using functions (spaghetti code)#include <stdio.h>int main() {    int scores[5] = {85, 92, 78, 90, 88};    int sum = 0, i;    double average;    // Calculate total score    for(i = 0; i < 5; i++) {        sum += scores[i];    }    // Calculate average score    average = (double)sum / 5;    printf("Average score: %.2f\n", average);    // Find highest score    int max = scores[0];    for(i = 1; i < 5; i++) {        if(scores[i] > max) {            max = scores[i];        }    }    printf("Highest score: %d\n", max);    return 0;}

Improved Code Using Functions:

#include <stdio.h>// Function declarationsdouble calculateAverage(int arr[], int n);int findMax(int arr[], int n);int main() {    int scores[5] = {85, 92, 78, 90, 88};    printf("Average score: %.2f\n", calculateAverage(scores, 5));    printf("Highest score: %d\n", findMax(scores, 5));    return 0;}// Function to calculate average scoredouble calculateAverage(int arr[], int n) {    int sum = 0, i;    for(i = 0; i < n; i++) {        sum += arr[i];    }    return (double)sum / n;}// Function to find maximum valueint findMax(int arr[], int n) {    int max = arr[0], i;    for(i = 1; i < n; i++) {        if(arr[i] > max) {            max = arr[i];        }    }    return max;}

Advantages of Modularity: Code is clearer, functionality is separated, and it is easier to test and maintain.

2. Function Definitions and Return Values

2.1 Basic Syntax Structure of Functions

Function Definition Format:

ReturnType FunctionName(ParameterList) {    // Function body    return ReturnValue;}

Detailed Explanation of Function Components:

1. Return Type: The type of value returned by the function, such as int, double, void, etc.

2. Function Name: The identifier of the function, following variable naming rules.

3. Parameter List: The input parameters received by the function, separated by commas.

4. Function Body: The block of code that implements the functionality.

5. Return Statement: Returns the result and ends the function execution.

2.2 Examples of Various Types of Functions

Void Functions (No Return Value):

#include <stdio.h>// Function declarationsvoid printWelcome();void printStars(int n);int main() {    printWelcome();      // Call no-argument function    printStars(10);      // Call function with argument    return 0;}// Print welcome message (no parameters, no return value)void printWelcome() {    printf("=== Welcome to the Student Grade Management System ===\n");}// Print n stars (with parameter, no return value)void printStars(int n) {    int i;    for(i = 0; i < n; i++) {        printf("*");    }    printf("\n");}

Functions with Return Values:

#include <stdio.h>// Function declarationsint add(int a, int b);double calculateCircleArea(double radius);int main() {    int result = add(5, 3);    printf("5 + 3 = %d\n", result);    double area = calculateCircleArea(2.5);    printf("Area of circle with radius 2.5: %.2f\n", area);    return 0;}// Addition function (returns int type)int add(int a, int b) {    return a + b;}// Function to calculate area of a circle (returns double type)double calculateCircleArea(double radius) {    const double PI = 3.14159;    return PI * radius * radius;}

2.3 Important Rules for Return Values

Function of the Return Statement:

1. Returns the computed result to the caller

2. Immediately ends function execution

3. Returns control to the caller

Common Pitfalls:

⚠️ Return value type must match: The declared return type of the function must be consistent with the actual return value type.

⚠️ Void functions cannot have return values: Void indicates no return value.

⚠️ Ensure all paths have a return value: If the function declaration has a return value, ensure all execution paths have a return statement.

// Error Example 1: Mismatched return value typedouble faultyFunction() {    return 10;  // 10 is int, but function declares return double}// Correct Versiondouble correctFunction() {    return 10.0;  // Returns double type}// Error Example 2: Void function attempts to return valuevoid wrongFunction() {    printf("Hello");    return 0;  // Error: void function cannot return value}// Correct Versionvoid correctFunction() {    printf("Hello");    return;  // Can be omitted, function will automatically return at the end}

3. Parameter Passing: Formal vs Actual Parameters

3.1 Formal Parameters vs Actual Parameters

Important Concept Distinction:

• Formal Parameters (Formals): Parameters declared in the function definition, serving as “placeholders” for the function.

• Actual Parameters (Actuals): Specific values passed during the function call.

Relationship Between Formals and Actuals:

#include <stdio.h>// Function definition: x and y are formal parametersint multiply(int x, int y) {    return x * y;}int main() {    int a = 5, b = 3;    // Function call: a and b are actual parameters    int result = multiply(a, b);    printf("%d × %d = %d\n", a, b, result);    // Can also directly pass constants    result = multiply(10, 2);    printf("10 × 2 = %d\n", result);    return 0;}

Characteristics of Formal Parameters:

• Formals are only valid within the function

• Formals are created when the function is called and destroyed when the function ends

• Formals are local variables of the function

3.2 Details of Parameter Passing

Passing Parameters of Basic Data Types:

#include <stdio.h>// Demonstrating the characteristics of value passingvoid modifyValue(int num) {    printf("Before modification in function: num = %d\n", num);    num = 100;  // Modify the value of the formal parameter    printf("After modification in function: num = %d\n", num);}int main() {    int number = 50;    printf("Before calling function: number = %d\n", number);    modifyValue(number);  // Pass the value of number    printf("After calling function: number = %d\n", number);    return 0;}

Execution Result:

Before calling function: number = 50Before modification in function: num = 50After modification in function: num = 100After calling function: number = 50

Key Understanding: Basic data types are passed by value, modifications to formals within the function do not affect actuals.

3.3 Designing Functions with Multiple Parameters

Design Principles:

1. Number of parameters should be moderate (usually no more than 5-7)

2. Related parameters can be combined into structures (to be learned later)

3. Order of parameters should be logical (important parameters first)

Example of a Function with Multiple Parameters:

#include <stdio.h>// Calculate final score of a studentdouble calculateFinalScore(double homework, double midterm, double final, double attendance) {    double finalScore;    // Weights: homework 20%, midterm 30%, final 40%, attendance 10%    finalScore = homework * 0.2 + midterm * 0.3 + final * 0.4 + attendance * 0.1;    return finalScore;}int main() {    double hw = 85.0, mid = 78.0, fin = 92.0, att = 95.0;    double score = calculateFinalScore(hw, mid, fin, att);    printf("Homework: %.1f, Midterm: %.1f, Final: %.1f, Attendance: %.1f\n", hw, mid, fin, att);    printf("Final score: %.1f\n", score);    return 0;}

4. In-Class Practical Exercises

Exercise 1: Prime Number Function

Problem Requirement: Write a function to determine if a number is prime, and test it in the main function.

#include <stdio.h>#include <math.h>// Function declarationint isPrime(int n);int main() {    int num;    printf("Please enter an integer: ");    scanf("%d", &num);    if(isPrime(num)) {        printf("%d is prime\n", num);    } else {        printf("%d is not prime\n", num);    }    // Test all prime numbers from 1 to 20    printf("Prime numbers from 1 to 20: ");    for(int i = 2; i <= 20; i++) {        if(isPrime(i)) {            printf("%d ", i);        }    }    printf("\n");    return 0;}// Function to determine if a number is primeint isPrime(int n) {    if(n < 2) return 0;  // Numbers less than 2 are not prime    if(n == 2) return 1; // 2 is prime    // Check for even numbers other than 2    if(n % 2 == 0) return 0;    // Check odd factors, only need to check up to sqrt(n)    for(int i = 3; i <= sqrt(n); i += 2) {        if(n % i == 0) {            return 0;  // Found a factor, not prime        }    }    return 1;  // Is prime}

Test Cases:

Input: 17Output: 17 is primePrime numbers from 1 to 20: 2 3 5 7 11 13 17 19

Exercise 2: Calculate Combination C(n, k)

Problem Requirement: Write a function to calculate the combination, using the formula C(n, k) = n! / (k! × (n-k)!)

#include <stdio.h>// Function declarationslong factorial(int n);long combination(int n, int k);int main() {    int n, k;    printf("Please enter values for n and k (n >= k >= 0): ");    scanf("%d %d", &n, &k);    if(k < 0 || k > n) {        printf("Invalid input!\n");        return 1;    }    long result = combination(n, k);    printf("C(%d, %d) = %ld\n", n, k, result);    return 0;}// Function to calculate factoriallong factorial(int n) {    long result = 1;    for(int i = 2; i <= n; i++) {        result *= i;    }    return result;}// Function to calculate combinationlong combination(int n, int k) {    return factorial(n) / (factorial(k) * factorial(n - k));}

Algorithm Optimization: The above implementation has repeated calculations, which can be optimized as follows:

long combination(int n, int k) {    // Use symmetry: C(n, k) = C(n, n-k)    if(k > n - k) {        k = n - k;    }    long result = 1;    for(int i = 1; i <= k; i++) {        result = result * (n - k + i) / i;    }    return result;}

Exercise 3: String Processing Function

Problem Requirement: Write a function to count the occurrences of a specific character in a string.

#include <stdio.h>// Function declarationint countChar(char str[], char ch);int main() {    char text[100];    char target;    printf("Please enter a string: ");    fgets(text, sizeof(text), stdin);    printf("Please enter the character to count: ");    scanf("%c", &target);    int count = countChar(text, target);    printf("Character '%c' appears %d times in the string\n", target, count);    return 0;}// Function to count character occurrencesint countChar(char str[], char ch) {    int count = 0;    int i = 0;    while(str[i] != '\0') {        if(str[i] == ch) {            count++;        }        i++;    }    return count;}

5. Frequently Asked Questions

Q: Why must functions be declared before use?

A: C language executes sequentially, and the compiler needs to know the return type and parameter types of the function to compile the function call correctly. The declaration informs the compiler of the function’s existence and format.

Q: When should the void return type be used?

A: Use void when the function only performs operations without needing to return results, such as printing menus or clearing screens.

Q: Can the names of formal and actual parameters be the same?

A: Yes, they are different variables with different scopes. However, for code clarity, it is recommended to use meaningful and different names.

Q: Can a function have multiple return statements?

A: Yes, but once a return statement is executed, the function immediately ends. Ensure all possible execution paths have a return value (for non-void functions).

6. Common Mistakes Summary

1. Forgetting Function Declarations: Calling a function before its definition requires prior declaration.

2. Mismatched Return Value Types: The declared return type must match the actual return value type.

3. Missing Return Statement: Non-void functions must ensure all execution paths have a return statement.

4. Parameter Type Mismatch: Actual and formal parameters must be compatible types.

5. Arrays as Parameters: When passing arrays as parameters, the address is passed (to be explained in detail in the next lesson).

7. Debugging Techniques

Using printf for Function Debugging:

int complexFunction(int a, int b) {    printf("Debug: Entering function, a=%d, b=%d\n", a, b);    int result = a + b;    printf("Debug: Calculation result=%d\n", result);    result *= 2;    printf("Debug: Final result=%d\n", result);    return result;}

Validating Function Boundary Conditions:

// Testing boundary conditions of the functionvoid testFunction() {    // Test normal cases    printf("Testing normal input: %d\n", add(5, 3));    // Test boundary values    printf("Testing zero: %d\n", add(0, 0));    printf("Testing negative numbers: %d\n", add(-5, 3));    // Test large values    printf("Testing large numbers: %d\n", add(1000000, 2000000));}

<Exercise Class>

1. Detailed Explanation of Typical Example Problems

Example Problem 1: Calculate the Sum of Two Numbers (Basic Function Application)

Problem Description: Write a function to calculate the sum of two integers and test it in the main function.

Solution Approach: This is the most basic function application, focusing on understanding function definition, parameter passing, and return values.

#include <stdio.h>// Function declarationint add(int a, int b);int main() {    int num1, num2, result;    printf("Please enter two integers: ");    scanf("%d %d", &num1, &num2);    // Call function to calculate sum    result = add(num1, num2);    printf("%d + %d = %d\n", num1, num2, result);    // Test multiple sets of data    printf("Testing other calculations:\n");    printf("10 + 20 = %d\n", add(10, 20));    printf("-5 + 8 = %d\n", add(-5, 8));    return 0;}// Function definition: Calculate the sum of two integersint add(int a, int b) {    int sum = a + b;  // Calculate sum    return sum;       // Return result}

Test Cases:

Input:

5 3

Output:

5 + 3 = 8Testing other calculations:10 + 20 = 30-5 + 8 = 3

Key Knowledge Points:

1. Function Declaration: Informs the compiler of the function’s existence and format.

2. Function Call: Calls the function using its name and actual parameters.

3. Return Value: Returns the computed result through the return statement.

Common Pitfalls:

⚠️ Function declaration and definition’s return type and parameter types must match.

⚠️ The number and types of actual parameters in function calls must match the formal parameters.

⚠️ Ensure non-void functions have a return statement in all execution paths.

Example Problem 2: Determine Leap Year Function (Function with Conditional Judgement)

Problem Description: Write a function to determine if a year is a leap year. The rules for leap years are: divisible by 4 but not by 100, or divisible by 400.

Solution Approach: Use conditional statements within the function to return a logical value.

#include <stdio.h>// Function declarationint isLeapYear(int year);int main() {    int year;    printf("Please enter a year: ");    scanf("%d", &year);    if(isLeapYear(year)) {        printf("%d is a leap year\n", year);    } else {        printf("%d is not a leap year\n", year);    }    // Test some special years    printf("Testing leap year determination:\n");    printf("2000: %s\n", isLeapYear(2000) ? "Leap Year" : "Common Year");    printf("1900: %s\n", isLeapYear(1900) ? "Leap Year" : "Common Year");    printf("2024: %s\n", isLeapYear(2024) ? "Leap Year" : "Common Year");    return 0;}// Function to determine if a year is a leap yearint isLeapYear(int year) {    // Leap year conditions: divisible by 4 but not by 100, or divisible by 400    if((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) {        return 1;  // Is a leap year    } else {        return 0;  // Is not a leap year    }}

Test Cases:

Input:

2024

Output:

2024 is a leap yearTesting leap year determination:2000: Leap Year1900: Common Year2024: Leap Year

Algorithm Optimization: A more concise version can be used:

int isLeapYear(int year) {    return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);}

Example Problem 3: Calculate Factorial Function (Return Value Verification)

Problem Description: Write a function to calculate the factorial of n (n!), paying attention to boundary conditions.

Solution Approach: Use a loop to calculate the factorial, noting that 0! = 1 is a special case.

#include <stdio.h>// Function declarationlong long factorial(int n);int main() {    int n;    printf("To calculate n!, please enter n: ");    scanf("%d", &n);    if(n < 0) {        printf("Error: Factorial is undefined for negative numbers!\n");        return 1;    }    long long result = factorial(n);    printf("%d! = %lld\n", n, result);    // Test factorials from 0 to 10    printf("\nFactorial table from 0 to 10:\n");    for(int i = 0; i <= 10; i++) {        printf("%d! = %lld\n", i, factorial(i));    }    return 0;}// Function to calculate factoriallong long factorial(int n) {    if(n == 0 || n == 1) {        return 1;  // 0! = 1, 1! = 1    }    long long result = 1;    for(int i = 2; i <= n; i++) {        result *= i;    }    return result;}

Test Cases:

Input:

5

Output:

5! = 120Factorial table from 0 to 10:0! = 11! = 12! = 23! = 64! = 245! = 1206! = 7207! = 50408! = 403209! = 36288010! = 3628800

Important Reminders:

⚠️ Factorials grow rapidly; 13! will exceed int range, use long long.

⚠️ 0 factorial is 1, needs special handling.

⚠️ Factorial of negative numbers is undefined, requires error checking.

2. Summary of Problem Types and Solution Techniques

2.1 Classification of Basic Function Problem Types

Type 1: Mathematical Calculation Functions

• Characteristics: Implement mathematical operations such as addition, subtraction, multiplication, division, factorial, power calculations, etc.

• Solution Template: Clearly define input and output, use appropriate data types.

• Examples: Addition function, factorial function, square root approximation.

Type 2: Judgment Functions

• Characteristics: Return boolean values or status codes, such as prime number determination, leap year determination.

• Solution Template: Use conditional statements, return 0/1 or true/false.

• Examples: isPrime(), isLeapYear(), isEven().

Type 3: Processing Functions

• Characteristics: Process and transform data, such as string processing, data formatting.

• Solution Template: Process input parameters, return processed results.

• Examples: String reversal, sum of digits.

2.2 Best Practices for Function Design

Function Design Principles:

1. Single Responsibility: A function should only perform one clear task.

2. Clear Interface: Parameters and return values should have clear meanings.

3. Error Handling: Validate and handle illegal inputs.

4. Code Reusability: Extract repeated code into functions.

Good Function Design Example:

// Good design: single functionality, clear interfacedouble calculateCircleArea(double radius) {    if(radius < 0) {        return -1;  // Error code    }    return 3.14159 * radius * radius;}

// Poor design: mixed functionalitydouble calculateAndPrint(double radius) {    // Calculates and outputs simultaneously, violating single responsibility principle    double area = 3.14 * radius * radius;    printf("Area: %f", area);    return area;}

3. Analysis of Common Mistakes and Debugging Techniques

3.1 Common Error Types

Error 1: Mismatched Return Value Types

// Error Exampleint add(int a, int b) {    return a + b + 0.5;  // Returns double, but function declares return int}

// Correct Versiondouble add(double a, double b) {    return a + b;}

Error 2: Forgetting Return Value

// Error Exampleint max(int a, int b) {    if(a > b) {        return a;  // Only returns value if condition is true    }    // Missing return value for else case}

// Correct Versionint max(int a, int b) {    if(a > b) {        return a;    } else {        return b;    }}

Error 3: Mismatch Between Formal and Actual Parameters

// Error Examplevoid printSum(int a, int b) {    printf("Sum: %d", a + b);}int main() {    printSum(5.5, 3.2);  // Passing double, but function requires int    return 0;}

3.2 Function Debugging Techniques

Using Print Statements to Debug Functions:

int complexFunction(int a, int b) {    printf("Debug: Entering function, a=%d, b=%d\n", a, b);    int temp = a * 2;    printf("Debug: Intermediate value temp=%d\n", temp);    int result = temp + b;    printf("Debug: Final result result=%d\n", result);    return result;}

Validating Function Boundary Conditions:

void testFunction() {    // Test normal cases    printf("Normal test: %d\n", add(5, 3));    // Test boundary values    printf("Zero test: %d\n", add(0, 0));    printf("Negative test: %d\n", add(-5, 3));    printf("Large number test: %d\n", add(1000000, 2000000));}

4. Homework Assignments

Basic Problems (Mandatory)

Problem 1: Calculate Triangle Area Function

Write a function to calculate the area of a triangle, using the formula: Area = Base × Height ÷ 2

Input Format: Base and height (floating point numbers)

Output Format: Area (rounded to 2 decimal places)

Test Cases:

Input:

5.0 3.0

Output: Triangle area: 

7.50

Problem 2: Determine Odd or Even Function

Write a function to determine the odd or even nature of an integer, returning 1 for odd and 0 for even.

Input Format: Integer n

Output Format: Odd/Even

Test Cases:

Input:

7

Output:

7 is odd

Input:

-4

Output:

-4 is even

Problem 3: Sum of Digits Function

Write a function to calculate the sum of the digits of an integer.

Input Format: Integer n

Output Format: Sum of digits

Test Cases:

Input:

1234

Output:

Sum of digits: 10

Input:

-567

Output:

Sum of digits: 18 (calculated using absolute value)

Advanced Problems (Optional)

Problem 4: Optimize Prime Number Determination Function

Improve the prime number determination function to optimize algorithm efficiency.

Problem 5: Calculate Combination Function

Write a function to calculate C(n, k) = n! / (k! × (n-k)!).

5. Homework Answers

Answer to Problem 1: Calculate Triangle Area

#include <stdio.h>// Function declarationdouble calculateTriangleArea(double base, double height);int main() {    double base, height;    printf("Please enter the base and height of the triangle: ");    scanf("%lf %lf", &base, &height);    if(base <= 0 || height <= 0) {        printf("Error: Base and height must be positive numbers!\n");        return 1;    }    double area = calculateTriangleArea(base, height);    printf("Triangle area: %.2f\n", area);    return 0;}// Function to calculate triangle areadouble calculateTriangleArea(double base, double height) {    return base * height / 2.0;}

Answer to Problem 2: Determine Odd or Even

#include <stdio.h>// Function declarationint isOdd(int n);int main() {    int num;    printf("Please enter an integer: ");    scanf("%d", &num);    if(isOdd(num)) {        printf("%d is odd\n", num);    } else {        printf("%d is even\n", num);    }    return 0;}// Function to determine odd or evenint isOdd(int n) {    // Use modulus operation to determine odd or even    // Note: Handle negative numbers: C language may return negative for modulus of negative numbers    if(n < 0) {        n = -n;  // Take absolute value    }    return n % 2 == 1;}// More robust version (handles all integers)int isOddBetter(int n) {    // Use bitwise operation, more efficient and correctly handles negative numbers    return (n & 1) == 1;}

Answer to Problem 3: Sum of Digits

#include <stdio.h>// Function declarationint sumOfDigits(int n);int main() {    int num;    printf("Please enter an integer: ");    scanf("%d", &num);    int sum = sumOfDigits(num);    printf("Sum of digits: %d\n", sum);    return 0;}// Function to calculate sum of digitsint sumOfDigits(int n) {    // Handle negative numbers: take absolute value    if(n < 0) {        n = -n;    }    int sum = 0;    // Loop to extract each digit    while(n > 0) {        sum += n % 10;  // Get the last digit        n /= 10;        // Remove the last digit    }    return sum;}

Answer to Problem 4: Optimize Prime Number Determination Function

#include <stdio.h>#include <math.h>// Function declarationint isPrime(int n);int main() {    int num;    printf("Please enter an integer: ");    scanf("%d", &num);    if(isPrime(num)) {        printf("%d is prime\n", num);    } else {        printf("%d is not prime\n", num);    }    return 0;}// Optimized prime number determination functionint isPrime(int n) {    if(n < 2) return 0;      // Numbers less than 2 are not prime    if(n == 2) return 1;     // 2 is prime    if(n % 2 == 0) return 0;  // Even numbers are not prime (except 2)    // Check odd factors, only need to check up to sqrt(n)    for(int i = 3; i <= sqrt(n); i += 2) {        if(n % i == 0) {            return 0;  // Found a factor, not prime        }    }    return 1;  // Is prime}

Answer to Problem 5: Calculate Combination

#include <stdio.h>// Function declarationslong long factorial(int n);long long combination(int n, int k);int main() {    int n, k;    printf("Please enter n and k (n >= k >= 0): ");    scanf("%d %d", &n, &k);    if(k < 0 || k > n) {        printf("Invalid input!\n");        return 1;    }    long long result = combination(n, k);    printf("C(%d, %d) = %lld\n", n, k, result);    return 0;}// Function to calculate factoriallong long factorial(int n) {    if(n == 0 || n == 1) {        return 1;    }    long long result = 1;    for(int i = 2; i <= n; i++) {        result *= i;    }    return result;}// Function to calculate combinationlong long combination(int n, int k) {    // Use properties of combinations: C(n,k) = C(n, n-k)    if(k > n - k) {        k = n - k;    }    // Direct calculation to avoid large factorials    long long result = 1;    for(int i = 1; i <= k; i++) {        result = result * (n - k + i) / i;    }    return result;}

6. Frequently Asked Questions

Q: Why must functions be declared before use?

A: C language executes sequentially, and the compiler needs to know the return type and parameter types of the function to compile the function call correctly. The declaration informs the compiler of the function’s existence and format.

Q: When should the void return type be used?

A: Use void when the function only performs operations without needing to return results, such as printing menus or clearing screens.

Q: Can the names of formal and actual parameters be the same?

A: Yes, they are different variables with different scopes. However, for code clarity, it is recommended to use meaningful and different names.

Q: Can a function have multiple return statements?

A: Yes, but once a return statement is executed, the function immediately ends. Ensure all possible execution paths have a return value (for non-void functions).

Q: Can functions call other functions internally?

A: Yes, this is called nested function calls. However, be careful to avoid infinite recursive calls.

Through today’s exercise class, I believe everyone has gained a deeper understanding of the basic use of functions. Functions are the foundation of modular programming, and mastering them is crucial for future learning. In the next class, we will learn about function calling mechanisms and parameter passing methods, which are key to understanding how functions work!