Home

Learning Hub

Articles

Actual and Formal Parameters in C: Key Differences Explained

Ever wonder how functions in C access the data they operate on?

You’re not alone.

One of the common operations in programming with C is the passing of information to functions. Functions, which consume inputs, do some processing and return the result.

But how does that data exactly end up in front of the function?

That’s where parameters come in.

Let’s dive into actual and formal parameters in C. We will break down the terms and why understanding them makes your code cleaner, faster, and easier to manage.

What are the Parameters?

Parameters are like the “middlemen” between the caller and the function. We feed it the data (actual parameters), and the function gets it by placeholders (formal parameters).

Parameters are variables that are used to pass on values or references between functions. There are two kinds of parameters: actual and formal parameters.

Why does this matter?

Well, it can change how your program behaves. If we don’t know how parameters work, we could end up passing the wrong data or, worse, crashing the program.

What Are Actual Parameters in C?

Let us first discuss actual parameters.

Actual parameters are those values that you pass to a function when it is called. It is almost like the real input a function needs to do its job. It is also called arguments.

They can be constants, variables, expressions, or even other function calls.

Here is an example:

In the code above, 10 and 5 are the actual parameters. These are then passed into the add function, which adds them together.

Also Read: Different Types of Functions in C

What Are Formal Parameters in C?

Now that we have the actual parameters, let’s discuss formal parameters.

Formal parameters are variables defined in the function header that receive the values of the actual parameters given during function calls. It is also called function parameters.

If actual parameters are the inputs, formal parameters are the hands ready to catch them.

Let us take the same example:

Now, in this function definition, a and b are formal parameters. They substitute whatever actual parameters we provide when we call the function.

Think of them as the receiving end of the function.

When the function is invoked, these actual parameters get assigned to the formal parameters. This automatically occurs in the background for this assignment.

Key Differences Between Actual and Formal Parameters in C

What’s the difference between actual and formal parameters in C? Here is a quick comparison:

Let’s look at the example below:

In this case:

• Actual parameter: userName (entered by the user)
• Formal parameter: name[] (used inside the greet function)

With this, the difference becomes clearer:

• Actual parameters are the real data we provide.
• Formal parameters are simply there to hold onto that data inside the function.

Also Read: Features of C Language

How Functions in C Pass Their Parameters

Here’s a general problem:

You write a function, pass in some parameters, and expect them to change, but nothing happens. You get frustrated trying to wonder why the values didn’t update.

Relax, we all get there.

The way you pass arguments really makes a big difference in C. The medium of passing data to a function may preserve it or allow the function to alter it in place.

In C programming, there are three major ways of passing parameters to a function:

• Passing by Value
• Passing by Reference
• Passing by Pointer

Each one works differently and can impact the output of your program in unique ways.

Passing Parameters by Value

In this method, when we pass parameters by value, then a copy of the actual parameter is passed to a function. This implies that the function works on the copy, not the original data.

This is pretty cool if we do not want the function to mess up our original values.

The catch?

Any changes we make inside the function don’t affect the actual parameter outside the function.

For instance, assume you pass a number into a function to increase it by 1. The function will alter the copy, not the original number.

Also Read: What is Recursion in C?

Passing Parameters by Reference

Passing by reference allows a function to access the real parameter directly. That means that every change that happens within the function is passed to the original value.

How does this work?

We pass the memory address of the variable instead of passing a copy. Then, the function can access and modify the actual data stored at that memory location.

This is helpful if we need the function to change the real data, like exchanging two numbers or a global variable.

Passing Parameters by Pointer

Passing by pointer is different from passing by reference. Instead of passing the address itself, we pass a pointer to the function that points to the memory address of the actual parameter.

This technique really shines when working with dynamic memory or arrays.

The function can then use this pointer to change both the value and the pointer itself. It gives us even more control over how data is manipulated within the function.

Code Examples for Different Parameter Passing Methods in C

Example 1: Passing Arguments by Value

We have two integers here. We pass them into a function. The function adds one to each number.

But because we passed by value, the change does not get carried out to the original numbers.

Output:

Here, inside the function, x and y are changed. But outside, a and b are still the same.

Why?

Because we passed by value. This function took a copy and not the original data.

Example 2: Swapping Values by Reference

Now, let’s try to pass by reference. We will write a function to swap two numbers.

Here again, since we’re going to pass by reference, the changes should be visible outside the function, too.

Output:

Here, values of a and b are swapped even outside the function.

That is because we passed to the function memory addresses of a and b, and it changed the actual data.

Also Read: Static Variable in C

Example 3: Pointers and Dynamic Memory Allocation

For the final example, we will use the pointers to dynamically allocate memory for an array.

We’ll pass a pointer to the function, which will allocate memory and fill the array.

Output:

Here, we use malloc() to allocate dynamic memory for the array.

The function has managed to change the array and fill it with values as we passed a pointer.

Are you puzzled by why your program doesn’t behave the way you would expect? Sometimes, the key can be traced to the method you are using to pass parameters.

With C, using the correct parameter-passing method is more than just a matter of preference;

It can determine everything from how your program executes to how your data is treated and whether your code is good enough to introduce bugs.

So why does this matter?

The answer is simple:

• Passing by value safeguards your original data but does not allow modifications.
• Passing by reference or pointer equips your function with the ability to modify the originals.

If you don’t know when to use which, you might get some really weird results.

• Protecting Data: If we don’t want our data changed, then pass by value.
• Modifying Data: If one needs to change the data, passing by reference or pointer is the way.
• Performance Considerations: Passing large data structures, such as arrays, by value is slower because a copy is made on the system side. Passing by reference or pointer avoids this overhead.

The right choice of method makes our code more predictable, easier to debug, and more efficient.

Best Practices for Working with Actual and Formal Parameters in C

Now that we know the methods let’s dive into best practices.

1. Match Data Types

The data types of actual and formal parameters always have to match.

If they do not, C performs implicit conversions, which can lead to behaviour you might not have expected.

For instance, if a float is passed while the function expects an int, there’s a possibility of creating rounding errors.

If the types mismatch, then it is safer to cast explicitly in the actual parameter.

2. Be Cautious with Pointers

Pointers are tricky. They are powerful but liable to memory errors if misused.

When passing by reference, ensure that pointers refer to valid memory locations. Avoid passing un-initialised pointers to a function, for example.

3. Use Descriptive Variable Names

This is obvious, but descriptive names for formal parameters make our code clearer.

This saves us and anyone else reading the code to quickly understand what each of them represents.

For example, instead of int x, int y, use int width and int height. It’s small, but it makes a big difference.

4. Be Aware of Array Passing

We need to remember that arrays are passed by reference by default. This implies that the function is allowed to modify the contents of the array.

If we don’t want this to happen, we can create a copy of the array or pass it as const.

5. Avoid Global Variables in Function Arguments

A function can modify global variables through arguments of a function, but this is bad practice. It makes the debugging and maintenance of code rather impractical.

Use local variables whenever possible, then pass them through actual parameters.

Conclusion

Knowing the meaning of actual and formal parameters in C is important for writing efficient and flexible code.

The passing method to control the data inside a function is determined by the decision whether to pass parameters by value, reference, or pointer. Passing by value protects the original data, whereas passing by reference or pointer allows direct modifications in the case of larger data structures or performance-sensitive applications.

Applying the right method will, therefore, allow you to control how functions relate to your data, which in turn means predictable programs and also efficient ones. This helps you write cleaner, faster, and safer code in C. It makes your programs more effective as well as easier to manage.

If you are passionate about mastering such concepts and extending your skills, join Hero Vired’s Certificate Program in Full Stack Development with Specialization for Web and Mobile. This course will equip you with the comprehensive skills needed for a proficient full-stack developer by studying both front-end and back-end technologies.