Why functions are needed - Visual Breakdown

Concept Flow - Why functions are needed

Start Program

↓

Write code directly

↓

Code grows bigger

↓

Hard to read and reuse

↓

Use functions to group code

↓

Call functions when needed

↓

Easier to read, reuse, and fix

↓

End Program

This flow shows how code starts simple, grows complex, and how functions help by grouping code for reuse and clarity.

Execution Sample

C

#include <stdio.h>

void greet() {
    printf("Hello!\n");
}

int main() {
    greet();
    greet();
    return 0;
}

This code defines a function greet() and calls it twice to print 'Hello!' two times.

Execution Table

Step	Action	Function Called	Output	Notes
1	Program starts	None		main() begins execution
2	Call greet()	greet	Hello!	First call prints greeting
3	Return from greet()	None		Back to main()
4	Call greet() again	greet	Hello!	Second call prints greeting
5	Return from greet()	None		Back to main()
6	Return 0 from main()	None		Program ends

💡 Program ends after main() returns 0

Variable Tracker

Variable	Start	After greet() call 1	After greet() call 2	Final
No variables	N/A	N/A	N/A	N/A

Key Moments - 3 Insights

Why do we call greet() twice instead of writing printf twice?

Using greet() groups the print code once, so we can reuse it easily without repeating code, as shown in steps 2 and 4 of the execution_table.

What happens when greet() finishes?

After greet() runs, the program returns to main() to continue, as seen in steps 3 and 5 of the execution_table.

Why is the program easier to read with functions?

Functions give names to code blocks, so main() looks simple and clear, making the program easier to understand and fix.

Visual Quiz - 3 Questions

Look at the execution_table, what is printed when greet() is called the first time?

A Nothing

B Goodbye!

C Hello!

D Error message

💡 Hint

Check row 2 in the execution_table where greet() is called and output is shown.

At which step does the program return from the second greet() call?

A Step 3

B Step 5

C Step 4

D Step 6

💡 Hint

Look at the execution_table rows showing return from greet(), the second return is at step 5.

If we did not use greet() and wrote printf twice, how would the execution_table change?

A There would be no function calls, just two print actions.

B There would be more function calls.

C The output would change to 'Goodbye!'.

D The program would not run.

💡 Hint

Think about how function calls appear in the execution_table and what happens if code is repeated instead.

Concept Snapshot

Functions group code into named blocks.
Call functions to reuse code without repeating.
Functions make programs easier to read and fix.
Without functions, code repeats and is harder to manage.
Functions return control back to caller after running.

Full Transcript

This lesson shows why functions are needed in C programming. When code grows, repeating the same lines makes it hard to read and fix. Functions let us group code once and call it many times. The example defines a greet() function that prints 'Hello!'. The main function calls greet() twice, so 'Hello!' prints two times. The execution table shows each step: starting main, calling greet, printing, returning, calling greet again, and ending. Variables are not used here, so no changes tracked. Key moments explain why calling greet() twice is better than repeating print, what happens after greet() finishes, and how functions improve readability. The quiz asks about outputs and steps from the execution table to check understanding. The snapshot summarizes that functions help organize and reuse code, making programs simpler and easier to maintain.