Returning Values from Functions in C++

Most functions in C++ return some value once their execution is complete. This return value is crucial for communicating the function’s result back to the code that called it. Some functions, however, are designed to perform an action without returning anything—these use the void return type.

To make the most of functions, it’s essential to understand:

How to define return types,
How to use the return statement, and
The different ways a function can return a result: by value, by reference, or by pointer.

🧩 Understanding Return Types

A return type tells the compiler (and the programmer) what kind of value the function will return.

Examples:

void display();        // Returns nothing
int sum(int a, int b); // Returns an int
double area(double r); // Returns a double

When you define a function, its return type must match what the function actually returns.

❗Important Rule

If a function is declared to return a specific type (e.g., int), but tries to return something else (e.g., a double or nothing), the compiler will generate an error.

Example:

int sum(int a, int b) {
    return a + b; // ✅ returns an int
}

int main() {
    int result = sum(10, 3); // result will be 13
    std::cout << result;
}

❗Early Return in `void` Functions

Even in void functions, you can use return; to exit early:

void print_message(int value) {
    if (value < 0) {
        std::cout << "Value is negative.\n";
        return;  // Early exit
    }
    std::cout << "Value is non-negative.\n";
}

int main() {
    print_message(-5); // Output: Value is negative.
    print_message(10); // Output: Value is non-negative.
}

🚀 The `return` Statement

The return statement has two key purposes:

Sends back a result to the caller
Terminates the function immediately

int add(int a, int b) {
    return a + b; // Function ends here
}

🔄 Ways to Return Values

C++ supports three primary methods to return results from a function:

Method	Description	Use Case
By value	Returns a copy of the result	Default, safe in most cases
By reference	Returns a reference to existing data	When caller needs to modify it
By pointer	Returns a memory address (pointer)	When working with arrays/dynamic mem

1. ✅ Return by Value

Returns a copy of the data to the caller. This is the most common and safest method, especially for primitive data types or small objects.

std::string greet() {
    return "Hello, World!";
}

int main() {
    std::string message = greet(); // A copy of the string is returned
    std::cout << message;
}

⚠️ Note:

Returning large objects by value may be expensive due to copying overhead. In such cases, consider returning by reference or using move semantics.

2. 🔁 Return by Reference

Returns an alias (reference) to the original variable, allowing the caller to access or modify it.

int& getLarger(int &a, int &b) {
    return (a > b) ? a : b;
}

int main() {
    int x = 10, y = 20;
    getLarger(x, y) = 100; // Modifies y
    std::cout << x << " " << y; // Output: 10 100
}

⚠️ Caution: Never return a reference to a local variable

int& badFunction() {
    int local = 5;
    return local; // ❌ Dangerous: local is destroyed after function ends
}

This causes undefined behavior (dangling reference).

3. ✳️ Return by Pointer

Returns the memory address of a value. This method is useful when working with dynamic memory, arrays, or when you might return nullptr.

int* findElement(int arr[], int size, int target) {
    for (int i = 0; i < size; ++i) {
        if (arr[i] == target) {
            return &arr[i]; // ✅ Safe: arr is not local
        }
    }
    return nullptr; // Not found
}

int main() {
    int data[] = {3, 7, 9, 2};
    int* found = findElement(data, 4, 9);
    if (found != nullptr)
        std::cout << "Found: " << *found;
    else
        std::cout << "Not found";
}

⚠️ Again: Never return the address of a local variable

int* badPointerFunction() {
    int temp = 42;
    return &temp; // ❌ Invalid pointer after function ends
}

✅ Summary

Concept	Key Point
Return type	Declares what the function sends back
void	Used when the function returns nothing
`return`	Ends the function and sends back a value (or just exits in `void` case)
By value	Safe and common; returns a copy
By reference	Efficient for large objects, allows modification but needs care
By pointer	Returns memory address; use with caution and avoid returning locals

🔒 Best Practices

Use return by value by default.
Use return by reference only when you’re sure the data being referenced will remain valid.
Use return by pointer when working with arrays or when a nullptr result is meaningful.
Avoid returning references or pointers to local variables.