C Notes
HubApplications of C Programming LanguageFeatures of C Programming LanguageHistory of C Programming LanguageWhat is C Language?Why Learn C Programming in 2024?First C Program - Hello World in C with ExplanationGCC Compiler - Complete Guide to GNU C CompilerInstall C Compiler on Linux - GCC Setup Guide for All DistrosInstall C Compiler on macOS - Xcode Command Line Tools and Homebrew GCCInstall C Compiler on Windows - MinGW, MSYS2, and WSL GuideSetup VS Code for C Programming - Complete Configuration GuideC Syntax Rules — Complete GuideComments in C ProgrammingConstants in C ProgrammingData Types in CIdentifiers in C ProgrammingKeywords in C ProgrammingStructure of a C ProgramVariables in C ProgrammingArithmetic Operators in C ProgrammingAssignment Operators in C ProgrammingBitwise Operators in C ProgrammingIncrement and Decrement Operators in CLogical Operators in C ProgrammingRelational Operators in C ProgrammingTernary Operator in C ProgrammingBreak Statement in C ProgrammingContinue Statement in C ProgrammingDo-While Loop in C ProgrammingFor Loop in C ProgrammingGoto Statement in C Programmingif-else Statement in C Programmingif Statement in C ProgrammingNested if Statements in C ProgrammingSwitch Statement in C ProgrammingWhile Loop in C ProgrammingFunction Arguments in C - Pass by Value vs Pass by ReferenceFunction Call in C ProgrammingFunction Declaration (Prototype) in CFunction Definition in C ProgrammingIntroduction to Functions in C ProgrammingRecursion in C ProgrammingReturn Statement in C ProgrammingStorage Classes in C ProgrammingArray Operations in C - Searching, Sorting, Insert and DeleteArray Programs in C - Reverse, Rotate, Duplicates, MergeIntroduction to Arrays in C ProgrammingMultidimensional Arrays in C ProgrammingOne Dimensional Arrays in C ProgrammingPassing Arrays to Functions in CTwo Dimensional Arrays in C ProgrammingString Comparison in C - strcmp, strncmp, Case-InsensitiveString Functions in C - strlen, strcpy, strcat, strcmpC String Handling Library - Complete string.h ReferenceString Manipulation in C - Reverse, Uppercase, PalindromeString Programs in C - Anagram, Word Count, Vowels, FrequencyStrings in C Programming - Complete IntroductionDouble Pointers in C - Pointer to PointerPointer Arithmetic in C ProgrammingPointer Declaration and Initialization in CPointer Programs in C - Swap, String Reversal, Dynamic AllocationPointers and Arrays in C - The Relationship ExplainedPointers and Functions in C - Pass by ReferenceIntroduction to Pointers in C ProgrammingVoid Pointers in C - Generic Pointers Guidecalloc() in C – Contiguous Memory AllocationDynamic Arrays in C – Runtime-Sized Arraysfree() in C – Releasing Dynamic Memorymalloc() in C – Dynamic Memory AllocationMemory Management Best Practices in Crealloc() in C – Resizing Dynamic MemoryBinary Files in C – fread and fwriteFile Handling in C – IntroductionFile Handling Projects in C – Student Records & Phone BookFile Modes in C – Complete Guidefopen() and fclose() in C – Opening and Closing FilesReading Files in C – fgetc, fgets, fscanf, freadWriting Files in C – fputc, fputs, fprintf, fwriteConditional Compilation in C – #ifdef, #ifndef, #if#define Macros in C – Constants and Macro FunctionsHeader Files in C – Creating Custom Headers#include Directive in C – File InclusionMacro Functions in C – Parameterized MacrosC Preprocessor – Overview and DirectivesGraphs in C – Adjacency Matrix, Adjacency List, BFS, and DFSHash Tables in C – Implementation, Collision Handling, and ChainingLinked List in C – Singly, Doubly, and Circular with ImplementationQueue in C – Linear, Circular, and Priority Queue ImplementationStack in C – Array and Linked List Implementation with ApplicationsTrees in C – Binary Search Tree Implementation with TraversalsC Programming Best Practices – Coding Standards, Safety, and PerformanceBit Fields in C – Definition, Use Cases, and Protocol HeadersC Standard Library Overview – All Headers and Common FunctionsCommand Line Arguments in C – argc and argv ExplainedDebugging Techniques in C – GDB, Valgrind, and SanitizersFunction Pointers in C – Complete Guide with ExamplesMemory Layout of a C Program – Text, Data, BSS, Heap, StackBank Management System in C – Complete Project with File StorageFile Encryption Tool in C – XOR Cipher ImplementationLibrary Management System in C – Complete Project with Source CodeMini Compiler in C – Lexer and Parser for Simple ExpressionsSnake Game in C – Console-Based Game with Source CodeStudent Management System in C – Complete Project with Source CodeC Programming Cheatsheet – Complete Quick Reference GuideTop 50 C Programming Interview Questions with Answers (2025)Memory Management Interview Questions in C with AnswersOutput Prediction Questions in C – What Will This Program Print?Pointer Interview Questions in C – Tricky Problems with AnswersCommon C Programming Errors and Solutions – Debugging GuideImportant C Programs – 50+ Frequently Asked Programs with SolutionsQuick Revision Notes for C Programming – Complete C in 10 MinutesRecommended C Programming Books – From Beginner to ExpertFormat Specifiers in C - Complete Referencegetchar() and putchar() in C Programminggets() and puts() in C ProgrammingC Input Output Programs and Examplesprintf() Function in C Programmingscanf() Function in C ProgrammingArrays of Structures in C – Managing CollectionsEnums in C – Enumerated Data TypesNested Structures in C – Struct Within StructPointers to Structures in C – Arrow OperatorStructures in C – User-Defined Data Typestypedef in C – Creating Type AliasesUnions in C – Shared Memory Data Types
Learn how to call functions in C: passing arguments, receiving return values, actual vs formal parameters, nested function calls, and the function call mechanism with stack frames.
Defining a function is only half the story — you also need to know how to call (invoke) it. A function call transfers program control from the current location to the function's body, executes its code, and then returns control back to where it was called. Understanding how function calls work, including the call stack mechanism, is essential for writing and debugging C programs.
Basic Function Call Syntax
Example
function_name(argument1, argument2, ...);
Or, if you want to capture the return value:
Example
variable = function_name(argument1, argument2, ...);
c example
#include <stdio.h>
int add(int a, int b) {
return a + b;
}
void greet(char *name) {
printf("Hello, %s!\n", name);
}
int main() {
// Function call without capturing return value
greet("Alice");
// Function call with return value stored
int sum = add(10, 20);
printf("Sum = %d\n", sum);
// Function call directly in expression
printf("3 + 4 = %d\n", add(3, 4));
return 0;
}Output
Hello, Alice! Sum = 30 3 + 4 = 7
Actual Parameters vs Formal Parameters
When you define a function, the variables in the parameter list are formal parameters (placeholders). When you call the function, the values you pass are actual parameters (arguments).
c example
#include <stdio.h>
// 'x' and 'y' are FORMAL parameters
int multiply(int x, int y) {
printf(" Formal params: x=%d, y=%d\n", x, y);
return x * y;
}
int main() {
int a = 5, b = 7;
// 'a' and 'b' are ACTUAL parameters (arguments)
printf("Calling multiply(a, b) where a=%d, b=%d\n", a, b);
int result = multiply(a, b);
printf("Result: %d\n\n", result);
// Expressions can also be actual parameters
printf("Calling multiply(3+2, 10-3)\n");
result = multiply(3 + 2, 10 - 3);
printf("Result: %d\n", result);
return 0;
}Output
Calling multiply(a, b) where a=5, b=7 Formal params: x=5, y=7 Result: 35 Calling multiply(3+2, 10-3) Formal params: x=5, y=7 Result: 35
Key point: Actual parameters are evaluated before being passed to formal parameters. The values are copied — modifying formal parameters inside the function doesn't affect the actuals.
Different Ways to Call Functions
1. Call with No Arguments, No Return
c example
#include <stdio.h>
void displayMenu(void) {
printf("1. New Game\n");
printf("2. Load Game\n");
printf("3. Exit\n");
}
int main() {
displayMenu(); // Simple call, nothing passed, nothing returned
return 0;
}Output
1. New Game 2. Load Game 3. Exit
2. Call with Arguments, No Return
Example
#include <stdio.h>
void printStars(int count) {
for (int i = 0; i < count; i++)
printf("*");
printf("\n");
}
void printRange(int start, int end) {
for (int i = start; i <= end; i++)
printf("%d ", i);
printf("\n");
}
int main() {
printStars(10);
printStars(5);
printRange(1, 10);
return 0;
}
Output
********** ***** 1 2 3 4 5 6 7 8 9 10
3. Call with No Arguments, Returns Value
Example
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int rollDice(void) {
return (rand() % 6) + 1;
}
int main() {
srand(time(NULL));
printf("Rolling dice 5 times:\n");
for (int i = 0; i < 5; i++) {
printf("Roll %d: %d\n", i + 1, rollDice());
}
return 0;
}
Output
Rolling dice 5 times: Roll 1: 4 Roll 2: 2 Roll 3: 6 Roll 4: 1 Roll 5: 5
4. Call with Arguments and Return Value
c example
#include <stdio.h>
float calculateBMI(float weight_kg, float height_m) {
return weight_kg / (height_m * height_m);
}
char *bmiCategory(float bmi) {
if (bmi < 18.5) return "Underweight";
if (bmi < 25.0) return "Normal";
if (bmi < 30.0) return "Overweight";
return "Obese";
}
int main() {
float weight = 70.0, height = 1.75;
float bmi = calculateBMI(weight, height);
printf("Weight: %.1f kg, Height: %.2f m\n", weight, height);
printf("BMI: %.1f (%s)\n", bmi, bmiCategory(bmi));
return 0;
}Output
Weight: 70.0 kg, Height: 1.75 m BMI: 22.9 (Normal)
Nested Function Calls
You can pass the return value of one function directly as an argument to another:
c example
#include <stdio.h>
int square(int n) {
return n * n;
}
int add(int a, int b) {
return a + b;
}
int doubleValue(int n) {
return n * 2;
}
int main() {
// Nested calls: add(square(3), square(4)) = add(9, 16) = 25
int result = add(square(3), square(4));
printf("3² + 4² = %d\n", result);
// Deep nesting: double(add(square(2), square(3)))
result = doubleValue(add(square(2), square(3)));
printf("2 × (2² + 3²) = %d\n", result);
// Function call as printf argument
printf("5² = %d\n", square(5));
return 0;
}Output
3² + 4² = 25 2 × (2² + 3²) = 26 5² = 25
How Function Calls Work (The Call Stack)
When a function is called, the system uses a call stack to manage execution:
- Push: Arguments and return address are pushed onto the stack
- Execute: Control transfers to the function; local variables are created on the stack
- Return: Result is placed in a register, stack frame is popped, control returns to caller
c example
#include <stdio.h>
void func3() {
printf(" Inside func3 (deepest level)\n");
}
void func2() {
printf(" Entering func2\n");
func3();
printf(" Back in func2\n");
}
void func1() {
printf("Entering func1\n");
func2();
printf("Back in func1\n");
}
int main() {
printf("Starting main\n");
func1();
printf("Back in main\n");
return 0;
}Output
Starting main Entering func1 Entering func2 Inside func3 (deepest level) Back in func2 Back in func1 Back in main
The stack during func3() looks like:
Example
| func3() | ← Top of stack (currently executing)
| func2() |
| func1() |
| main() | ← Bottom of stack
Function Calls with Arrays
When passing arrays to functions, you're actually passing a pointer to the first element:
Example
#include <stdio.h>
void printArray(int arr[], int size) {
printf("[");
for (int i = 0; i < size; i++) {
printf("%d%s", arr[i], (i < size - 1) ? ", " : "");
}
printf("]\n");
}
int findMax(int arr[], int size) {
int max = arr[0];
for (int i = 1; i < size; i++) {
if (arr[i] > max) max = arr[i];
}
return max;
}
float findAverage(int arr[], int size) {
int sum = 0;
for (int i = 0; i < size; i++) sum += arr[i];
return (float)sum / size;
}
int main() {
int numbers[] = {34, 78, 12, 95, 56, 42};
int size = sizeof(numbers) / sizeof(numbers[0]);
printf("Array: ");
printArray(numbers, size);
printf("Maximum: %d\n", findMax(numbers, size));
printf("Average: %.1f\n", findAverage(numbers, size));
return 0;
}
Output
Array: [34, 78, 12, 95, 56, 42] Maximum: 95 Average: 52.8
Order of Argument Evaluation
Warning: The order in which function arguments are evaluated is unspecified in C:
Example
#include <stdio.h>
int counter = 0;
int getNext() {
return ++counter;
}
int main() {
// DANGER: Order of evaluation is unspecified!
// printf("%d %d %d\n", getNext(), getNext(), getNext());
// Could print "1 2 3" or "3 2 1" or anything else!
// SAFE: Use separate calls
int a = getNext();
int b = getNext();
int c = getNext();
printf("%d %d %d\n", a, b, c);
return 0;
}
Output
1 2 3
Practical Example: Function Composition
Example
#include <stdio.h>
#include <string.h>
int countVowels(char *str) {
int count = 0;
while (*str) {
char c = *str | 32; // Convert to lowercase
if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u')
count++;
str++;
}
return count;
}
int countWords(char *str) {
int count = 0, inWord = 0;
while (*str) {
if (*str == ' ' || *str == '\t' || *str == '\n') {
inWord = 0;
} else if (!inWord) {
inWord = 1;
count++;
}
str++;
}
return count;
}
void analyzeText(char *text) {
printf("Text: \"%s\"\n", text);
printf("Length: %lu characters\n", strlen(text));
printf("Words: %d\n", countWords(text));
printf("Vowels: %d\n", countVowels(text));
printf("\n");
}
int main() {
analyzeText("Hello World");
analyzeText("C programming is fun and powerful");
return 0;
}
Output
Text: "Hello World" Length: 11 characters Words: 2 Vowels: 3 Text: "C programming is fun and powerful" Length: 33 characters Words: 6 Vowels: 10
Interview Questions
Q1: What is the difference between actual and formal parameters?
Formal parameters are the variables declared in the function definition header — they're placeholders that receive values. Actual parameters (arguments) are the values or expressions passed during the function call. Actual parameter values are copied into formal parameters (in call-by-value).
Q2: What happens if you call a function with more or fewer arguments than it expects?
With a proper prototype in scope, the compiler generates an error for mismatched argument counts. Without a prototype (implicit declaration), extra arguments are ignored and missing arguments produce undefined behavior. This is why prototypes are essential.
Q3: In what order are function arguments evaluated?
The order of evaluation of function arguments is unspecified in C — the compiler can evaluate them in any order. Never rely on a specific order or use side effects (like i++) in multiple arguments. Evaluate separately if order matters.
Q4: Can a function call itself?
Yes, this is called recursion. A function calling itself with modified arguments, combined with a base case to stop, is a powerful technique for solving problems like factorials, tree traversal, and divide-and-conquer algorithms. Each recursive call gets its own stack frame.
Q5: What is the overhead of a function call?
Function calls have overhead: pushing arguments to the stack, saving the return address, jumping to the function code, creating local variables, and returning. For tiny functions called frequently (like in tight loops), this overhead may be significant. The inline keyword (C99) suggests the compiler eliminate this overhead by inserting the function body directly at the call site.
Summary
- A function call transfers control to the function body and returns after execution
- Actual parameters (values passed) are copied into formal parameters (defined in function)
- Functions can be called with or without arguments, and with or without capturing return values
- Nested function calls pass one function's return value as another's argument
- The call stack manages function execution — each call gets its own stack frame
- Argument evaluation order is unspecified — never rely on a specific order
- Arrays are passed as pointers, not copied (so they can be modified by the function)
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Function Call in C Programming.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this C Programming topic.
Search Terms
c-programming, c programming, programming, functions, function, call, function call in c programming
Related C Programming Topics
Continue learning this concept
FunctionsFunction Arguments in C - Pass by Value vs Pass by ReferenceUnderstand how arguments are passed to functions in C: pass by value vs pass by reference (using pointers). Learn when to use each approach with practical examples and common patterns.FunctionsFunction Declaration (Prototype) in CLearn function declarations and prototypes in C programming. Understand why prototypes are needed, syntax rules, implicit declarations, and best practices for declaring functions before use.FunctionsFunction Definition in C ProgrammingLearn how to define functions in C: syntax, return types, parameters, function body, local variables, and the complete anatomy of a function definition with practical examples.FunctionsIntroduction to Functions in C ProgrammingLearn what functions are in C, why theyFunctionsRecursion in C ProgrammingMaster recursion in C: base cases, recursive cases, stack frames, factorial, Fibonacci, tower of Hanoi, and more. Understand when recursion beats iteration and common pitfalls.FunctionsReturn Statement in C ProgrammingLearn the return statement in C: returning values from functions, void functions, multiple return points, returning pointers, and common mistakes. Complete guide with practical examples.