Table of Contents

What is the Return Statement?

The return statement in C terminates the execution of a function and sends a value back to the calling function. It also exits the current function immediately.

Two Main Purposes

Purpose	Description
Exit the function	Stops execution at that point, no further code runs
Return a value	Sends a result back to where the function was called

Basic Syntax

return;           // For void functions (no value)
return value;     // Returns a specific value
return expression; // Returns result of expression

Example 1: Return in Void Functions

#include <stdio.h>
// Void function with no return value
void greet() {
printf("Hello!\n");
return;  // Optional, exits function
printf("This line never executes!\n");
}
int main() {
greet();
printf("Back in main\n");
return 0;
}

Output:

Hello!
Back in main

Example 2: Return Values from Functions

#include <stdio.h>
// Returns an integer value
int add(int a, int b) {
int result = a + b;
return result;  // Returns value to caller
}
// Returns result of expression directly
int multiply(int a, int b) {
return a * b;   // Shorter version
}
int main() {
int sum = add(5, 3);        // sum = 8
int product = multiply(4, 2); // product = 8
printf("Sum: %d\n", sum);
printf("Product: %d\n", product);
// Can use return value directly in printf
printf("Direct: %d\n", add(10, 20));
return 0;
}

Output:

Sum: 8
Product: 8
Direct: 30

Example 3: Early Return (Exiting Early)

#include <stdio.h>
// Check if number is positive
int checkPositive(int num) {
if(num <= 0) {
return 0;  // Exit early - not positive
}
// This code runs only if num > 0
printf("Processing positive number: %d\n", num);
return 1;  // Positive
}
int main() {
checkPositive(-5);   // Exits early at return 0
checkPositive(10);   // Runs full function
return 0;
}

Output:

Processing positive number: 10

Example 4: Return Multiple Types

#include <stdio.h>
// Return char
char getGrade(int score) {
if(score >= 90) return 'A';
if(score >= 80) return 'B';
if(score >= 70) return 'C';
return 'F';
}
// Return float
float calculateAverage(int a, int b, int c) {
return (a + b + c) / 3.0;
}
// Return pointer (string)
char* getStatus(int score) {
if(score >= 60) return "Pass";
return "Fail";
}
int main() {
printf("Grade: %c\n", getGrade(85));
printf("Average: %.2f\n", calculateAverage(10, 20, 30));
printf("Status: %s\n", getStatus(75));
return 0;
}

Output:

Grade: B
Average: 20.00
Status: Pass

Example 5: Return in Different Function Types

#include <stdio.h>
// int return type
int getMax(int x, int y) {
if(x > y) return x;
return y;
}
// float return type
float getPi() {
return 3.14159;
}
// double return type
double calculateArea(double radius) {
return 3.14159 * radius * radius;
}
// char array return (pointer to string)
char* getMessage() {
return "Hello from function!";
}
int main() {
printf("Max: %d\n", getMax(15, 8));
printf("Pi: %.5f\n", getPi());
printf("Area: %.2f\n", calculateArea(5.0));
printf("Message: %s\n", getMessage());
return 0;
}

Example 6: Return with Complex Logic

#include <stdio.h>
#include <string.h>
// Find first vowel in a string
char findFirstVowel(char str[]) {
for(int i = 0; str[i] != '\0'; i++) {
char c = str[i];
if(c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') {
return c;  // Return first vowel found
}
}
return '\0';  // No vowel found, return null character
}
// Factorial using recursion (returns result)
int factorial(int n) {
if(n <= 1) return 1;      // Base case
return n * factorial(n - 1); // Recursive case
}
// Validate age with multiple returns
int validateAge(int age) {
if(age < 0) return -1;    // Invalid: negative
if(age > 150) return -2;  // Invalid: too old
return 1;                  // Valid
}
int main() {
char vowel = findFirstVowel("hello");
if(vowel != '\0') {
printf("First vowel: %c\n", vowel);
}
printf("Factorial of 5: %d\n", factorial(5));
int result = validateAge(25);
if(result == 1) {
printf("Age is valid\n");
} else {
printf("Invalid age\n");
}
return 0;
}

Output:

First vowel: e
Factorial of 5: 120
Age is valid

Example 7: Return with Arrays (Using Pointers)

#include <stdio.h>
// Return pointer to array (be careful with local arrays!)
int* getEvens() {
static int evens[] = {2, 4, 6, 8, 10};  // Static to persist after return
return evens;
}
// Return sum of array elements
int sumArray(int arr[], int size) {
int sum = 0;
for(int i = 0; i < size; i++) {
sum += arr[i];
}
return sum;
}
int main() {
// Access returned array
int *evens = getEvens();
printf("First even: %d\n", evens[0]);
int numbers[] = {1, 2, 3, 4, 5};
int total = sumArray(numbers, 5);
printf("Sum: %d\n", total);
return 0;
}

Important Rules

Rule	Explanation	Example
Return type must match	Function return type and returned value must match	`int func()` → can't `return 3.14`
Void functions	Can use `return;` (no value) or omit it	`void func() { return; }`
Non-void functions	Must return a value (except `main()` can omit)	`int func() { return 0; }`
Stops execution	Code after `return` never runs	`return; printf("No");`
Single return per call	Only one `return` executes per function call	Multiple conditional returns possible

Common Mistakes

// MISTAKE 1: Wrong return type
int getValue() {
return 3.14;  // Warning! Double to int conversion
}
// MISTAKE 2: Missing return in non-void function
int isPositive(int x) {
if(x > 0) {
return 1;
}
// Error: No return if x <= 0
}
// CORRECT:
int isPositive(int x) {
if(x > 0) return 1;
return 0;  // Always return something
}
// MISTAKE 3: Returning local array address
int* getArray() {
int arr[] = {1, 2, 3};  // Local array
return arr;  // BUG! arr destroyed after return
}
// CORRECT: Use static or malloc
int* getArray() {
static int arr[] = {1, 2, 3};
return arr;  // OK - static persists
}

Return in main() Function

#include <stdio.h>
#include <stdlib.h>
int main() {
int result = 0;
// Return values in main indicate program status
// 0 = success, non-zero = error
if(some_error_occurred) {
return 1;  // Error code 1
}
return 0;  // Success
}
// You can check return value in shell:
// $ ./program
// $ echo $?  (shows 0 if success)

Return vs Break vs Exit

Statement	Scope	Effect
return	Current function	Exits function, returns to caller
break	Loop or switch	Exits loop/switch only
exit()	Entire program	Terminates whole program

#include <stdio.h>
#include <stdlib.h>
void testBreak() {
for(int i = 1; i <= 5; i++) {
if(i == 3) break;      // Exits loop only
printf("%d ", i);       // Prints: 1 2
}
printf(" - After loop\n");  // This runs
}
void testReturn() {
for(int i = 1; i <= 5; i++) {
if(i == 3) return;      // Exits function completely
printf("%d ", i);       // Prints: 1 2
}
printf("This never runs\n"); // Never runs
}
void testExit() {
for(int i = 1; i <= 5; i++) {
if(i == 3) exit(0);      // Exits entire program
printf("%d ", i);        // Prints: 1 2
}
}
int main() {
printf("Break: ");
testBreak();
printf("\nReturn: ");
testReturn();
printf("\nExit: ");
testExit();  // Program ends here
printf("This never prints\n");
return 0;
}

Quick Reference Table

Function Type	Return Statement	Example
void	`return;` or just `}`	`void greet() { printf("Hi"); }`
int	`return value;`	`int add(int a, int b) { return a+b; }`
float/double	`return value;`	`double pi() { return 3.14; }`
char	`return 'char';`	`char getFirst() { return 'A'; }`
pointer	`return &variable;`	`char* getName() { return "John"; }`
struct	`return struct_var;`	`Point getOrigin() { return p; }`

Summary

return → Exits function and optionally sends back a value
Type must match between function declaration and returned value
Early return is useful for validation and error checking
Only one return executes per function call (though multiple conditional returns are fine)
main() return 0 indicates successful program execution
Void functions can have empty return; or none at all

Complete C Programming Guide + Compilers Collection

1. C srand() Function – Understanding Seed Initialization

https://macronepal.com/understanding-the-c-srand-function
Explains how srand() initializes the pseudo-random number generator in C by setting a seed value. Using the same seed produces the same sequence, while time(NULL) gives different results each run.

2. C rand() Function Mechanics and Limitations

https://macronepal.com/c-rand-function-mechanics-and-limitations
Explains how rand() generates pseudo-random numbers between 0 and RAND_MAX, its deterministic nature, and limitations for security use cases.

3. C log() Function

https://macronepal.com/c-log-function-2
Covers natural logarithm calculation using <math.h> and its applications.

4. Mastering Date and Time in C

https://macronepal.com/mastering-date-and-time-in-c
Explains <time.h> functions like time(), clock(), difftime(), and struct tm.

5. Mastering time_t Type in C

https://macronepal.com/mastering-the-c-time_t-type-for-time-management
Explains time representation as seconds since Unix epoch and conversion functions.

6. C exp() Function

https://macronepal.com/c-exp-function-mechanics-and-implementation
Explains exponential function exp(x) and its scientific applications.

7. C log() Function (Alternate Guide)

https://macronepal.com/c-log-function
Comparison of log() and log10() with usage examples.

8. C log10() Function

https://macronepal.com/mastering-the-log10-function-in-c
Explains base-10 logarithm for engineering and scientific applications.

9. C tan() Function

https://macronepal.com/understanding-the-c-tan-function
Explains tangent function and radian-based calculations.

10. Random Numbers in C (Secure vs Predictable)

https://macronepal.com/mastering-c-random-numbers-for-secure-and-predictable-applications
Explains difference between rand() and secure randomness methods.

11. Free Online C Compiler

https://macronepal.com/free-online-c-code-compiler-2
Browser-based compiler for testing C programs instantly.

C Functions, Arguments, Parameters & Flow

Mastering Functions in C – Complete Guide

https://macronepal.com/c/mastering-functions-in-c-a-complete-guide/
Covers function structure, modular programming, and real-world usage.

Function Arguments in C

https://macronepal.com/c-function-arguments/
Explains how arguments are passed and used in function calls.

Function Parameters in C

https://macronepal.com/c-function-parameters/
Explains defining inputs for functions and matching them with arguments.

Function Declarations in C

https://macronepal.com/c-function-declarations-syntax-rules-and-best-practices/
Covers prototypes, syntax rules, and best practices.

Function Calls in C

https://macronepal.com/understanding-function-calls-in-c-syntax-mechanics-and-best-practices/
Explains execution flow and parameter handling during function calls.

Void Functions in C

https://macronepal.com/understanding-void-functions-in-c-syntax-patterns-and-best-practices/
Explains functions that do not return values.

Return Values in C

https://macronepal.com/c-return-values-mechanics-types-and-best-practices/
Explains different return types and how functions return results.

Pass-by-Value in C

https://macronepal.com/aws/understanding-pass-by-value-in-c-mechanics-implications-and-best-practices/
Explains how copies of variables are passed into functions.

Pass-by-Reference in C

https://macronepal.com/c/understanding-pass-by-reference-in-c-pointers-semantics-and-safe-practices/
Explains using pointers to modify original variables.

C strstr() Function

https://macronepal.com/aws/c-strstr-function/
Explains substring search inside strings in C.

C Preprocessor & Macros

C Structures, Memory, Scope & Linkage

C Scope, Storage Classes & Typedef

Extra Articles

https://macronepal.com/13757-2/
https://macronepal.com/13748-2/
https://macronepal.com/13747-2/
https://macronepal.com/13746-2/
https://macronepal.com/13745-2/
https://macronepal.com/13708-2/
https://macronepal.com/13707-2/
https://macronepal.com/13702-2/

Online Compilers

Complete Guide to Core & Advanced C Programming Concepts (Functions, Strings, Arrays, Loops, I/O, Control Flow)

https://macronepal.com/bash/building-blocks-of-c-a-complete-guide-to-functions/
Explains how functions in C work as reusable blocks of code, including declaration, definition, parameters, return values, and modular programming structure.

https://macronepal.com/bash/the-heart-of-text-processing-a-complete-guide-to-strings-in-c-2/
Explains how strings are handled in C using character arrays, string manipulation techniques, and common library functions for text processing.

https://macronepal.com/bash/the-cornerstone-of-data-organization-a-complete-guide-to-arrays-in-c/
Explains arrays in C as structured memory storage for multiple values, including indexing, initialization, and efficient data organization.

https://macronepal.com/bash/guaranteed-execution-a-complete-guide-to-the-do-while-loop-in-c/
Explains the do-while loop in C, where the loop body executes at least once before checking the condition.

https://macronepal.com/bash/mastering-iteration-a-complete-guide-to-the-for-loop-in-c/
Explains the for loop in C, including initialization, condition checking, and increment/decrement for controlled iteration.

https://macronepal.com/bash/mastering-iteration-a-complete-guide-to-while-loops-in-c/
Explains the while loop in C, focusing on condition-based repetition and proper loop control mechanisms.

https://macronepal.com/bash/beyond-if-else-a-complete-guide-to-switch-case-in-c/
Explains switch-case statements in C, enabling multi-branch decision-making based on variable values.

https://macronepal.com/bash/mastering-conditional-logic-a-complete-guide-to-if-else-statements-in-c/
Explains if-else statements in C for decision-making and controlling program flow based on conditions.

https://macronepal.com/bash/mastering-the-fundamentals-a-complete-guide-to-arithmetic-operations-in-c/
Explains arithmetic operations in C such as addition, subtraction, multiplication, division, and operator precedence.

https://macronepal.com/bash/foundation-of-c-programming-a-complete-guide-to-basic-input-output/
Explains basic input and output in C using scanf and printf for interacting with users and displaying results.

Online C Code Compiler
https://macronepal.com/free-online-c-code-compiler-2/

What is the Return Statement?

Two Main Purposes

Basic Syntax

Example 1: Return in Void Functions

Example 2: Return Values from Functions

Example 3: Early Return (Exiting Early)

Example 4: Return Multiple Types

Example 5: Return in Different Function Types

Example 6: Return with Complex Logic

Example 7: Return with Arrays (Using Pointers)

Important Rules

Common Mistakes

Return in main() Function

Return vs Break vs Exit

Quick Reference Table

Summary

Complete C Programming Guide + Compilers Collection

1. C srand() Function – Understanding Seed Initialization

2. C rand() Function Mechanics and Limitations

3. C log() Function

4. Mastering Date and Time in C

5. Mastering time_t Type in C

6. C exp() Function

7. C log() Function (Alternate Guide)

8. C log10() Function

9. C tan() Function

10. Random Numbers in C (Secure vs Predictable)

11. Free Online C Compiler

C Functions, Arguments, Parameters & Flow

Mastering Functions in C – Complete Guide

Function Arguments in C

Function Parameters in C

Function Declarations in C

Function Calls in C

Void Functions in C

Return Values in C

Pass-by-Value in C

Pass-by-Reference in C

C strstr() Function

C Preprocessor & Macros

C Structures, Memory, Scope & Linkage

C Scope, Storage Classes & Typedef

Extra Articles

Online Compilers

Leave a Reply Cancel reply

Macro Nepal Helper