Return From Void Functions in C++

In C++, functions are a fundamental building block for organizing code. A function can have a return type, which indicates the type of value it will send back to the calling code, or it can have a void return type. A void function, by definition, does not return a value. However, there are still important aspects to understand about termination and the role of the return statement within void functions. This blog will explore the details of returning from void functions in C++, including syntax, common practices, and best practices.

Table of Contents#

  1. What is a void Function?
  2. The return Statement in void Functions
  3. Common Practices
  4. Best Practices
  5. Example Usage
  6. Conclusion
  7. References

What is a void Function?#

A void function is a function that does not return a value. The void keyword is used as the return type in the function declaration. void functions are typically used for performing actions that do not require a result to be sent back to the calling code, such as printing output, modifying global variables, or interacting with hardware.

Here is a simple example of a void function:

#include <iostream>
 
// A void function that prints a message
void printMessage() {
    std::cout << "This is a message from the void function." << std::endl;
}
 
int main() {
    printMessage();
    return 0;
}

In this example, the printMessage function has a void return type, and it simply prints a message to the console. The main function calls printMessage, and the program then continues execution after the function call.

The return Statement in void Functions#

In C++, the return statement in a void function is used to terminate the function's execution prematurely. Unlike functions with a non - void return type, a return statement in a void function does not require an expression to be returned.

The syntax of the return statement in a void function is as follows:

return;

When the return statement is encountered in a void function, the function immediately stops executing, and control is transferred back to the calling code.

Common Practices#

Premature Termination#

One common practice is to use the return statement to exit a void function early when certain conditions are met. This can improve the readability and performance of the code.

#include <iostream>
 
void checkNumber(int num) {
    if (num < 0) {
        std::cout << "Number is negative. Exiting..." << std::endl;
        return;
    }
    std::cout << "Number is non - negative." << std::endl;
    // Other code can follow here
}
 
int main() {
    checkNumber(-5);
    checkNumber(10);
    return 0;
}

In this example, if the input number is negative, the function prints a message and exits early using the return statement. Otherwise, it continues with the rest of the function's execution.

Using return at the End#

It is also common to use a return statement at the end of a void function, even though it is not strictly necessary. This can make the code more consistent with the style of functions that have a non - void return type.

void doSomething() {
    // Function body
    return; // Optional, but consistent with style
}

Best Practices#

Keep Functions Short and Focused#

Using the return statement to exit a void function early can help keep functions short and focused. If a function has a complex set of conditions, early returns can make the code easier to understand.

Add Comments for Early Returns#

When using early returns, it is a good practice to add comments to explain the reason for the early termination. This can make the code more maintainable, especially for other developers who may need to work on the code in the future.

void processData(int data) {
    // If data is zero, there's nothing to process
    if (data == 0) {
        return;
    }
    // Process the data
}

Example Usage#

Let's consider a more complex example of a void function that processes an array. The function will stop processing the array if it encounters a specific value.

#include <iostream>
 
void processArray(int arr[], int size) {
    for (int i = 0; i < size; ++i) {
        if (arr[i] == -1) {
            std::cout << "Found -1. Stopping processing." << std::endl;
            return;
        }
        std::cout << "Processing element: " << arr[i] << std::endl;
    }
    std::cout << "Finished processing the array." << std::endl;
}
 
int main() {
    int arr1[] = {1, 2, 3, -1, 4};
    int arr2[] = {1, 2, 3, 4, 5};
 
    processArray(arr1, 5);
    processArray(arr2, 5);
 
    return 0;
}

In this example, the processArray function iterates through the array. If it encounters the value -1, it prints a message and exits the function using the return statement. Otherwise, it continues processing all the elements in the array.

Conclusion#

In C++, void functions provide a way to perform actions without returning a value. The return statement in a void function is used for premature termination of the function. By following common and best practices, such as using early returns for improved readability and adding comments, developers can write more maintainable and efficient code. Understanding how to return from void functions is an important aspect of mastering C++ programming.

References#

  • Stroustrup, Bjarne. "The C++ Programming Language." Addison - Wesley Professional, 4th Edition, 2013.
  • C++ Standard Library documentation: https://en.cppreference.com/w/
2026-07