Function prototypes - Step-by-Step Execution

Concept Flow - Function prototypes

Write function prototype

↓

Use function in main

↓

Compiler checks prototype

↓

Call function with correct args?

No→Error

Yes↓

Function definition later

↓

Program compiles and runs

The compiler first sees the function prototype, then checks calls against it before the function is defined.

Execution Sample

C

int add(int a, int b);  

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

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

This code declares a function prototype for add, calls it in main, then defines it later.

Execution Table

Step	Action	Evaluation	Result
1	Read prototype: int add(int a, int b);	Compiler stores signature	Allows calls before definition
2	Enter main function	Ready to execute main	Variables initialized
3	Call add(3, 4)	Check prototype matches call	Match found, call allowed
4	Jump to add function definition	Execute add with a=3, b=4	Return 7
5	Store return value in result	result = 7	Ready for next statement
6	main returns 0	Program ends	Successful execution

💡 Program ends after main returns 0

Variable Tracker

Variable	Start	After add call	Final
a	N/A	3	N/A (local to add)
b	N/A	4	N/A (local to add)
result	undefined	7	7

Key Moments - 3 Insights

Why do we need a function prototype before calling the function?

The prototype tells the compiler the function's name, return type, and parameters so it can check calls before seeing the full function. See step 1 and 3 in the execution_table.

What happens if the function call does not match the prototype?

The compiler gives an error because the call does not match the expected parameters. This is checked at step 3 in the execution_table.

Can the function be defined after main if we have a prototype?

Yes, the prototype allows calling the function before its full definition, as shown by steps 1 and 4.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'result' after step 5?

A 7

B 3

C undefined

D 0

💡 Hint

Check the 'result' variable in variable_tracker after the add call.

At which step does the compiler check if the function call matches the prototype?

A Step 1

B Step 3

C Step 4

D Step 6

💡 Hint

Look at the 'Action' and 'Evaluation' columns in execution_table.

If we remove the prototype line, what will happen when compiling?

A Program compiles and runs normally

B Function runs but returns wrong value

C Compiler error at function call

D Program runs but main returns 1

💡 Hint

Recall why the prototype is needed from key_moments and execution_table step 3.

Concept Snapshot

Function prototypes declare a function's name, return type, and parameters before its use.
They let the compiler check calls before the full function is defined.
Syntax: return_type function_name(parameter_types);
Without prototypes, calls before definitions cause errors.
Prototypes improve code organization and compilation safety.

Full Transcript

In C programming, a function prototype is a declaration that tells the compiler about a function's name, return type, and parameters before the function is actually defined. This allows you to call the function in your code before writing its full definition. The compiler uses the prototype to check that calls to the function have the correct number and types of arguments. If the call does not match the prototype, the compiler will give an error. This helps catch mistakes early. The prototype is usually placed at the top of the file or in a header file. When the program runs, the function is called as usual, and the definition is used to execute the function's code. This way, prototypes help organize code and ensure correctness during compilation.

Practice

1. What is the main purpose of a function prototype in C?

easy

A. To allocate memory for the function variables

B. To declare the function's name, return type, and parameters before its definition

C. To execute the function immediately

D. To define the function's full body and logic

Solution

1. Step 1: Understand what a function prototype declares

   A function prototype tells the compiler the function's name, return type, and parameter types without the body.

2. Step 2: Differentiate prototype from definition and execution

   It does not define the function's body or execute it; it only declares its interface.

3. Final Answer:

   To declare the function's name, return type, and parameters before its definition -> Option B

4. Quick Check:

   Function prototype = declaration before definition [OK]

Hint: Prototypes declare function signature only, no body [OK]

Common Mistakes:

• Confusing prototype with function definition
• Thinking prototype runs the function
• Believing prototype allocates memory

2. Which of the following is a correct function prototype in C for a function named sum that takes two integers and returns an integer?

easy

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

B. int sum(int a, int b) {}

C. void sum(int a, int b);

D. int sum(a, b);

Solution

1. Step 1: Check the syntax of a function prototype

   A prototype includes return type, function name, parameter types, and ends with a semicolon.

2. Step 2: Evaluate each option

   int sum(int a, int b); matches the correct syntax. int sum(int a, int b) {} has braces (function body), so it's a definition. void sum(int a, int b); has wrong return type (void). int sum(a, b); lacks parameter types.

3. Final Answer:

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

4. Quick Check:

   Prototype = return type + name + parameters + semicolon [OK]

Hint: Prototype ends with semicolon and no braces [OK]

Common Mistakes:

• Adding braces {} in prototype
• Omitting parameter types
• Using wrong return type

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

int add(int x, int y);
int main() {
    int result = add(3, 4);
    printf("%d", result);
    return 0;
}
int add(int a, int b) {
    return a + b;
}

medium

A. 34

B. Compilation error

C. 7

D. 0

Solution

1. Step 1: Understand the prototype and function call

   The prototype declares add before main, so the compiler knows its signature.

2. Step 2: Trace the function execution

   add(3, 4) returns 3 + 4 = 7, which is printed by printf.

3. Final Answer:

   7 -> Option C

4. Quick Check:

   Function call returns sum 3+4=7 [OK]

Hint: Prototype allows calling function before definition [OK]

Common Mistakes:

• Expecting compilation error without prototype
• Confusing concatenation with addition
• Ignoring return value

4. Identify the error in the following code snippet:

int multiply(int a, int b);
int main() {
    int x = multiply(2, 3);
    printf("%d", x);
    return 0;
}
int multiply(int a, b) {
    return a * b;
}

medium

A. No error, code runs fine

B. Missing return type in function definition

C. Missing semicolon after prototype

D. Incorrect parameter declaration in function definition

Solution

1. Step 1: Compare prototype and definition parameters

   The prototype declares int multiply(int a, int b); but the definition has int multiply(int a, b) missing type for b.

2. Step 2: Understand C parameter declaration rules

   Each parameter must have a type. Missing type for b causes a syntax error.

3. Final Answer:

   Incorrect parameter declaration in function definition -> Option D

4. Quick Check:

   All parameters need types in definition [OK]

Hint: All parameters must have types in definition [OK]

Common Mistakes:

• Omitting type for one parameter
• Assuming prototype fixes definition errors
• Missing semicolon after prototype

5. You want to declare a function prototype for processData that takes an array of integers and its size, then returns a float average. Which prototype is correct?

hard

A. float processData(int arr[], int size);

B. float processData(int arr, int size);

C. int processData(int[] arr, int size);

D. float processData(int *arr);

Solution

1. Step 1: Identify correct parameter types for array and size

   In C, an array parameter can be declared as int arr[] or int *arr, but size must be separate.

2. Step 2: Check return type and parameters

   Function returns a float average, so return type is float. float processData(int arr[], int size); matches this with int arr[] and int size.

3. Final Answer:

   float processData(int arr[], int size); -> Option A

4. Quick Check:

   Array parameter + size + float return = correct prototype [OK]

Hint: Array parameter needs type[] and size parameter [OK]

Common Mistakes:

• Using wrong return type
• Omitting size parameter
• Incorrect array parameter syntax