Function parameters and return values in C++

In C++, functions can have parameters (inputs) and return values (outputs) to make them more flexible and versatile. Parameters allow you to pass values into a function, and return values allow functions to provide results to the calling code.

Function Parameters

Definition of Function Parameters

Parameters are variables declared within the parentheses following the function name. Parameters allow you to pass values into the function for processing.

// Function with parameters int add(int a, int b) { return a + b; }

Passing Arguments to a Function

When calling a function, you provide actual values, known as arguments, for the parameters.

int result = add(3, 4); // 3 and 4 are arguments

Parameter Types

Parameters can have different data types, allowing functions to work with various types of data.

void printMessage(std::string message) { std::cout << message << std::endl; }

Pass by Value and Pass by Reference in C++

In C++, when you pass data to a function, you can choose between two methods: pass by value and pass by reference. These methods determine how the function interacts with the original data. Here are the details for each, along with examples:

Pass by Value

In pass by value, a copy of the argument is made, and the function operates on this copy. The original data outside the function remains unchanged. It's suitable when you want to work with a local copy of the data, preserving the original value.

void modifyValue(int x) { x = x + 10; }

Example of Pass by Value:

int num = 5; modifyValue(num); // The value of 'num' remains 5 after the function call.

Pass by Reference

In pass by reference, you pass the actual variable by reference (using &), allowing the function to directly modify the original data. It's useful when you want the function to make changes to the original data.

void modifyValue(int& x) { x = x + 10; }

Example of Pass by Reference:

int num = 5; modifyValue(num); // After the function call, 'num' is now 15.

Const Pass by Reference

When you pass a variable as a const reference, it prevents the function from modifying the original data, ensuring data integrity. It's used when you want to make the function read-only or when you want to avoid unnecessary data copying for large objects.

void displayValue(const int& x) { std::cout << x << std::endl; }

Example of Const Pass by Reference:

int num = 5; displayValue(num); // The value of 'num' is not modified by the function call.

In c++, pass by value makes a copy of the data for the function to work on, pass by reference allows the function to modify the original data, and const pass by reference enables read-only access to the data. The choice between these methods depends on your specific requirements for data manipulation and performance optimization.

Function Return Values

Definition of Return Values

A function can specify a return type to indicate what type of value it will provide as a result.

The return statement is used to return a value from a function.

int add(int a, int b) { return a + b; }

Returning Values

To return a value, use the return statement, and the returned value must match the function's specified return type.

int result = add(3, 4); // The result is 7

Void Return Type

If a function has a void return type, it does not return any value. It is often used for functions that perform tasks without producing a result.

void printMessage(std::string message) { std::cout << message << std::endl; }


Function parameters allow data to be passed into functions for processing, enhancing flexibility by supporting different data types and values. Return values enable functions to provide results, making them versatile and capable of producing meaningful output, which can be essential for creating efficient and reusable code. By using parameters and return values, functions become essential building blocks for developing modular and organized C++ programs.