C Programming Day 8: Functions in C | Parameters, Arguments & Return Values

C Programming Day 8

Introduction

Welcome to Day 8 of the C Programming Full Course.

Your C programming journey is moving from basic programming concepts toward more structured and reusable code.

In the previous lessons, you learned about:

• Variables and data types
• Operators
• Input and output
• Conditional statements
• Loops
• Arrays
• Strings

Now it's time to learn another fundamental concept: Functions in C.

Functions allow you to divide a large program into smaller, organized, reusable blocks of code.

Instead of writing the same instructions repeatedly, you can create a function once and call it whenever you need it.

For example:

calculateTotal();

or:

displayMenu();

This makes programs easier to understand, test, debug, and maintain.

What is a Function in C?

A function is a reusable block of code designed to perform a particular task.

For example, instead of writing addition code several times, you can create:

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

Then call it whenever necessary:

result = add(10, 20);

The function receives input, performs its task, and can return a result.

Why Are Functions Important?

Imagine a program with thousands of lines of code.

If everything is written inside main(), the program can quickly become difficult to understand.

Functions allow us to divide the program into logical sections.

For example:

Main Program
│
├── Login Function
├── Menu Function
├── Input Function
├── Calculation Function
├── Report Function
└── Exit Function

Each function can handle a specific responsibility.

Advantages of Functions in C

Functions provide several important benefits.

1. Code Reusability

Write the code once and use it multiple times.

2. Better Organization

Large programs can be divided into smaller sections.

3. Easier Debugging

Problems can be isolated within individual functions.

4. Improved Readability

Function names can clearly describe what a section of code does.

5. Easier Maintenance

Changing one function can update the behavior wherever that function is called.

Types of Functions in C

Functions can broadly be divided into two categories:

1. Library Functions

These functions are provided by the C standard library.

Examples:

printf()
scanf()
strlen()
sqrt()

They become available through appropriate header files.

2. User-Defined Functions

These are functions created by the programmer.

Example:

void greet()
{
    printf("Welcome to C Programming!");
}

Basic Function Structure

A function generally contains:

Return Type
     ↓
Function Name
     ↓
Parameters
     ↓
Function Body

Example:

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

Here:

• int → return type
• add → function name
• int a, int b → parameters
• return a + b; → returned result

Three Main Steps of Using a Function

A user-defined function commonly involves three important parts:

1. Function declaration
2. Function definition
3. Function call

Let's understand each one.

1. Function Declaration

A function declaration tells the compiler about the function before it is used.

Syntax

return_type function_name(parameter_list);

Example

int add(int, int);

This tells the compiler that there is a function named add that:

• Returns an int
• Accepts two integer parameters

2. Function Definition

The function definition contains the actual code that performs the task.

Example

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

The function receives two numbers and returns their sum.

3. Function Call

A function does not execute simply because it has been defined.

We need to call it.

Example

int result = add(10, 20);

Here, add() is called with two arguments.

Complete Function Example

Let's combine declaration, definition, and calling.

#include <stdio.h>

int add(int a, int b);
int add(int a, int b)
{
    return a + b;
}
int main()
{
    int result;
    result = add(10, 20);
    printf("Sum = %d", result);
    return 0;
}

Output

Sum = 30

Function Syntax

The general structure of a function is:

return_type function_name(parameters)
{
    // statements
}

For example:

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

Let's break this down.

int

The return type.

multiply

The function name.

int a, int b

The parameters.

return a * b;

The value returned by the function.

What Are Parameters in C?

Parameters are variables listed in the function definition.

For example:

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

Here, a and b are parameters.

They receive values when the function is called.

What Are Arguments in C?

Arguments are the actual values passed to a function when it is called.

For example:

add(10, 20);

Here:

• 10 is an argument
• 20 is an argument

The values are passed to:

int add(int a, int b)

So:

a = 10
b = 20

Parameters vs Arguments

Parameters                                                           Arguments

Appear in function definition           Appear in function call

Act as variables                                Are actual values or expressions

Example: int a                                Example: 10

Example

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

add(10, 20);

a and b are parameters.
10 and 20 are arguments.

Functions Without Parameters

A function does not always need parameters.

Example

#include <stdio.h>

void welcome()
{
    printf("Welcome to C Programming!");
}
int main()
{
    welcome();
    return 0;
}

Output

Welcome to C Programming!

Here, welcome() does not accept any arguments.

Functions With Parameters

A function can accept one or more parameters.

Example

#include <stdio.h>

void displayNumber(int number)
{
    printf("Number = %d", number);
}
int main()
{
    displayNumber(50);
    return 0;
}

Output

Number = 50

Functions With a Return Value

A function can calculate something and return the result.

Example

#include <stdio.h>

int square(int number)
{
    return number * number;
}
int main()
{
    int result;
    result = square(5);
    printf("Square = %d", result);
    return 0;
}

Output

Square = 25

The function:

square(5)

returns:

25

Functions Without a Return Value

When a function does not need to return a value, we can use the void return type.

Example

#include <stdio.h>

void message()
{
    printf("Learning C is fun!");
}
int main()
{
    message();
    return 0;
}

The function performs an action but does not return a value.

Four Common Function Forms in C

Functions can commonly be categorized into four forms.

1. No Parameters, No Return Value

void display()
{
    printf("Hello");
}

Call:

display();

2. Parameters, No Return Value

void display(int number)
{
    printf("%d", number);
}

Call:

display(10);

3. No Parameters, With Return Value

int getNumber()
{
    return 100;
}

Call:

int number = getNumber();

4. Parameters, With Return Value

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

Call:

int result = add(10, 20);

This fourth form is extremely common in practical programming.

Example: Calculate the Maximum of Two Numbers

Let's create a function that finds the larger of two numbers.

#include <stdio.h>

int maximum(int a, int b)
{
    if (a > b)
        return a;
    else
        return b;
}
int main()
{
    int result;
    result = maximum(25, 40);
    printf("Maximum = %d", result);
    return 0;
}

Output

Maximum = 40

Example: Check Even or Odd Using a Function

Functions can also be used with conditional logic.

#include <stdio.h>

void checkEvenOdd(int number)
{
    if (number % 2 == 0)
        printf("%d is even.", number);
    else
        printf("%d is odd.", number);
}
int main()
{
    checkEvenOdd(15);
    return 0;
}

Output

15 is odd.

Example: Calculate Factorial Using a Function

Let's create a function to calculate the factorial of a number.

#include <stdio.h>

int factorial(int n)
{
    int i;
    int result = 1;
    for (i = 1; i <= n; i++)
    {
        result = result * i;
    }
    return result;
}
int main()
{
    int number = 5;
    printf("Factorial = %d", factorial(number));
    return 0;
}

Output

Factorial = 120

The function can now be reused for different numbers.

Function Prototype in C

A function prototype is another name commonly used for a function declaration.

For example:

int add(int a, int b);

It tells the compiler the function's:

• Name
• Return type
• Number of parameters
• Parameter types

The parameter names can also be omitted:

int add(int, int);

Both forms are valid declarations.

Why Do We Need Function Prototypes?

Consider this program:

#include <stdio.h>

int main()
{
    printf("%d", add(10, 20));
    return 0;
}
int add(int a, int b)
{
    return a + b;
}

The function is defined after main().

A function prototype can make the function known before its first use:

#include <stdio.h>

int add(int a, int b);
int main()
{
    printf("%d", add(10, 20));
    return 0;
}
int add(int a, int b)
{
    return a + b;
}

This is a common and organized way to structure C programs.

The return Statement

The return statement sends a value back to the calling function.

Example

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

If we call:

int result = add(5, 7);

the function returns:

12

The returned value is stored in result.

A function with a void return type does not return a value to the caller.

Local Variables in Functions

Variables declared inside a function are generally local to that function.

Example

#include <stdio.h>

void test()
{
    int number = 10;
    printf("%d", number);
}
int main()
{
    test();
    return 0;
}

The variable number belongs to the function where it is declared.

You cannot normally access that local variable directly from main().

Passing Values to Functions

By default, C passes function arguments by value.

This means the function receives a copy of the value.

Example

#include <stdio.h>

void change(int number)
{
    number = 100;
}
int main()
{
    int number = 50;
    change(number);
    printf("%d", number);
    return 0;
}

Output

50

The original variable remains 50 because the function changed its local copy.

Later in this C programming series, we will learn how pointers allow functions to modify data through addresses.

Advantages of Using Functions

Functions provide several benefits.

Code Reusability

Write code once and use it many times.

Modularity

Break a large program into smaller sections.

Easier Testing

Individual functions can be tested separately.

Easier Maintenance

Changes can often be made in one function without rewriting the entire program.

Improved Readability

Well-named functions make programs easier to understand.

Common Mistakes When Using Functions

Mistake 1: Forgetting the Function Declaration

If a function is used before it has been declared, you may encounter compiler issues.

Use a prototype when appropriate:

int add(int, int);

Mistake 2: Using the Wrong Return Type

If a function returns an integer, use:

int

For example:

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

Mistake 3: Forgetting to Return a Value

If a non-void function is expected to return a value, make sure the appropriate execution paths return one.

Mistake 4: Confusing Parameters and Arguments

Remember:

int add(int a, int b)

contains parameters.

While:

add(10, 20);

contains arguments.

Mistake 5: Calling the Wrong Function

Make sure the function name used in the call matches the function definition.

For example:

calculateSum();

is different from:

calculate_sum();

C is case-sensitive and identifiers must match exactly.

Practical Program: Simple Calculator Using Functions

Let's combine several functions to create a simple calculator.

#include <stdio.h>

int add(int a, int b)
{
    return a + b;
}
int subtract(int a, int b)
{
    return a - b;
}
int multiply(int a, int b)
{
    return a * b;
}
int main()
{
    int a = 20;
    int b = 5;
    printf("Addition = %d\n", add(a, b));
    printf("Subtraction = %d\n", subtract(a, b));
    printf("Multiplication = %d\n", multiply(a, b));
    return 0;
}

Output

Addition = 25
Subtraction = 15
Multiplication = 100

This example demonstrates why functions are useful: each mathematical operation has its own reusable piece of code.

Best Practices for Writing Functions

When creating functions in C, follow these practices:

Use Meaningful Names

Prefer:

calculateTotal()

over:

abc()

Keep Functions Focused

A function should ideally perform one clear task.

Use Appropriate Return Types

Return meaningful results when the caller needs them.

Avoid Unnecessary Repetition

Move repeated logic into reusable functions.

Keep Your Functions Manageable

Very large functions can be difficult to understand and maintain.

Practice Questions

Now it's your turn to practice.

Question 1

Write a function that prints:

Welcome to C Programming

Question 2

Write a function that accepts two integers and returns their sum.

Question 3

Write a function that accepts a number and returns its square.

Question 4

Write a function that checks whether a number is positive, negative, or zero.

Question 5

Write a function to find the largest of three numbers.

Question 6

Write a function to calculate the factorial of a number.

Question 7

Create a calculator using separate functions for addition, subtraction, multiplication, and division.

Quick Revision

Let's review today's most important concepts.

• A function is a reusable block of code designed to perform a specific task.
• Functions help make programs modular and reusable.
• A function can have parameters.
• Arguments are values passed during a function call.
• A function can return a value.
• void is used when a function does not return a value.
• A function prototype declares a function before its use.
• The return statement sends a value back to the caller.
• C passes ordinary function arguments by value.
• User-defined functions help organize large programs.

Conclusion

Functions are one of the most important building blocks of C programming.

They allow you to divide complex programs into smaller, reusable sections. Instead of placing all your code inside main(), you can create separate functions for individual tasks such as calculating a sum, checking a number, processing data, or performing a calculation.

Today, you learned about function declaration, function definition, function calls, parameters, arguments, return values, prototypes, and different types of functions.

The best way to understand functions is to practice creating your own.

In the next lesson, we will continue our C Programming Tutorial series and explore another fundamental concept that will help you write more powerful programs.

Keep coding, keep practicing, and continue your C programming journey!

Frequently Asked Questions (FAQ)

What is a function in C?

A function in C is a block of reusable code that performs a specific task.

Why are functions used in C programming?

Functions are used to reduce code repetition, improve organization, make programs easier to maintain, and divide complex programs into smaller tasks.

What is a function prototype in C?

A function prototype is a declaration that tells the compiler about a function's name, return type, and parameter types before the function is used.

What is the difference between parameters and arguments?

Parameters are variables defined in a function declaration or definition, while arguments are the actual values passed when the function is called.

What is a return value in C?

A return value is data sent from a function back to the code that called it.

What does void mean in a C function?

void indicates that a function does not return a value.

Can a C function have multiple parameters?

Yes. A C function can have multiple parameters, provided they are declared correctly.

← Previous Post Loading...

Next Post → Loading...