What does 'return' do in C++ 🔙

Metadata

• Date :: 12-04-2025
• Tags :: cpp

---

Notes

Detailed Notes on the return Keyword in C++

1. Introduction to the return Keyword

The return keyword in C++ is used to send a value from a function back to the location where the function was called. This allows the function to provide a result or output to the caller, making functions more useful and dynamic.

• Purpose: The primary role of the return keyword is to return a value to the calling function or program.
• Location: The return keyword is generally used at the end of a function to return a result.

When a function is called, the returned value can be assigned to a variable or used directly in an expression, depending on the needs of the program.

2. Function Returning Values

In C++, a function can return a value to the caller. To return a value, you must specify the data type of the value being returned. If the function is not supposed to return any value, the void keyword is used.

1. Returning a Value: If the function is expected to return a value, you need to change the return type from void to the data type of the value you are returning.
2. Data Types for Return Values: The return type of the function must match the data type of the value being returned. Common data types include int, double, string, etc.

3. Example: Calculating the Area of a Square

Let’s go through an example where a function calculates the area of a square and returns the result using the return keyword.

// Function Declaration
double square(double length);  // Declaring a function that returns a double
 
int main() {
    double length = 5.0;
    double area = 0.0;  // Variable to store the returned value
 
    // Function Call
    area = square(length);  // Calling the function and storing the returned value
    std::cout << "Area of the square: " << area << " cm²" << std::endl;  // Display result
 
    return 0;
}
 
// Function Definition
double square(double length) {
    return length * length;  // Returning the area (length * length)
}
 

• In this example, the square function calculates the area of a square (side × side) and returns the result as a double data type.
• The return keyword sends the calculated value (length * length) back to where the function was called (inside main()).
• The return type of square is double because we are returning a double value (the calculated area).

4. Shortened Function Return Example

Instead of assigning the result to a temporary variable, you can directly return the result in a single line.

double square(double length) {
    return length * length;  // Directly returning the result in one line
}
 

This is often preferred for short, simple calculations, where you don’t need extra variables to store intermediate results.

5. Example: Calculating the Volume of a Cube

Next, let’s look at a function that calculates the volume of a cube and returns the result using the return keyword.

// Function Declaration
double cube(double length);
 
int main() {
    double length = 6.0;
    double volume = 0.0;
 
    // Function Call
    volume = cube(length);
    std::cout << "Volume of the cube: " << volume << " cm³" << std::endl;
 
    return 0;
}
 
// Function Definition
double cube(double length) {
    return length * length * length;  // Returning the volume (side³)
}
 

• The cube function calculates the volume of a cube, which is the cube of the side length (length³), and returns it.
• We return the result using the return keyword.

6. Returning String Values

You can also use the return keyword to return strings from a function. Here’s an example where we create a function to concatenate a user’s first and last name and return the full name.

// Function Declaration
std::string concatStrings(std::string firstName, std::string lastName);
 
int main() {
    std::string firstName = "John";
    std::string lastName = "Doe";
    std::string fullName;
 
    // Function Call
    fullName = concatStrings(firstName, lastName);
    std::cout << "Full Name: " << fullName << std::endl;
 
    return 0;
}
 
// Function Definition
std::string concatStrings(std::string firstName, std::string lastName) {
    return firstName + " " + lastName;  // Returning the concatenated full name
}
 

• In this example, the function concatStrings takes two string parameters, concatenates them with a space in between, and returns the full name.
• The return type of the function is std::string because we are returning a string.

7. Important Notes on the return Keyword

• Return Type: Always ensure that the function’s return type matches the type of the value being returned. If a function returns an integer, the return type should be int. If it returns a string, the return type should be std::string, etc.
• Position of return: The return keyword is typically found at the end of the function. It immediately terminates the function and returns the specified value to the calling function.
• Void Functions: If a function doesn’t need to return any value, you use the void keyword as the return type, and no return statement is necessary (although you can still use return to exit early from the function if needed).

void sayHello() {
    std::cout << "Hello, World!" << std::endl;
    return;  // Optional in a void function, but can be used to exit early
}
 

• Returning Multiple Values: C++ functions can only return one value at a time. However, you can return multiple values by using arrays, structs, or pointers, or by passing variables by reference.

8. Summary of Key Concepts

• return keyword: Used to send a value back to the caller function.
• Function Return Type: The return type of the function must match the data type of the returned value.
• Returning Simple Values: For simple tasks (like calculating an area), a function can return a value directly (e.g., return length * length;).
• Returning Complex Values: Functions can also return complex data types, such as strings, by concatenating or manipulating them.
• Void Functions: Functions with void as the return type don’t return any value, but they can still use return to exit early.

Conclusion

The return keyword is an essential part of functions in C++. It allows you to send computed or generated values back to the caller function. This makes functions more flexible and reusable. When using the return keyword, always ensure that the return type of your function matches the type of the value you are returning. Whether you’re working with numbers, strings, or more complex types, the return keyword is key to making your functions useful and functional.

---

References

• Video
• C++ user defined functions explained 📞