Function Syntax

In C++, functions allow us to group a set of statements together and execute them whenever we need to. They provide modularity and reusability to our code.

Here's an example of a function in C++:

1#include <iostream>
2using namespace std;
3
4// Function declaration
5int multiply(int a, int b);
6
7int main() {
8  // Function call
9  int result = multiply(5, 3);
10
11  // Print the result
12  cout << "The result is: " << result << endl;
13
14  return 0;
15}
16
17// Function definition
18int multiply(int a, int b) {
19  return a * b;
20}

In this example:

• We declare a function multiply that takes two integer parameters a and b and returns their product.
• Inside the main function, we call the multiply function with arguments 5 and 3 and store the result in the result variable.
• Finally, we print the result using the cout object.

The output of this program would be:

1The result is: 15

xxxxxxxxxx

#include <iostream>

using namespace std;

​

// Function declaration

int multiply(int a, int b);

​

int main() {

  // Function call

  int result = multiply(5, 3);

​

  // Print the result

  cout << "The result is: " << result << endl;

​

  return 0;

}

​

// Function definition

int multiply(int a, int b) {

  return a * b;

}

Parameters and Arguments

When defining a function, you can specify one or more parameters. Parameters are like variables that are defined in the function's declaration and are used to pass values into the function. When calling a function, you can provide arguments which correspond to the parameters of the function.

Let's take a look at an example:

1#include <iostream>
2using namespace std;
3
4// Function declaration
5int add(int a, int b);
6
7int main() {
8  int num1, num2, sum;
9
10  cout << "Enter first number: ";
11  cin >> num1;
12
13  cout << "Enter second number: ";
14  cin >> num2;
15
16  // Function call
17  sum = add(num1, num2);
18
19  // Print the sum
20  cout << "Sum: " << sum << endl;
21
22  return 0;
23}
24
25// Function definition
26int add(int a, int b) {
27  return a + b;
28}

In this example:

• We declare a function add that takes two integer parameters a and b.
• Inside the main function, we prompt the user to enter two numbers and store them in num1 and num2 respectively.
• We then call the add function with the arguments num1 and num2 to calculate their sum.
• Finally, we print the sum using the cout object.

You can run the above code to see it in action!

xxxxxxxxxx

#include <iostream>

using namespace std;

​

// Function declaration

int add(int a, int b);

​

int main() {

  int num1, num2, sum;

​

  cout << "Enter first number: ";

  cin >> num1;

​

  cout << "Enter second number: ";

  cin >> num2;

​

  // Function call

  sum = add(num1, num2);

​

  // Print the sum

  cout << "Sum: " << sum << endl;

​

  return 0;

}

​

// Function definition

int add(int a, int b) {

  return a + b;

}

Return Values

In C++, a function can also return a value. The return value of a function is specified in the function's definition, and it represents the result of the function's computation.

To specify a return value, you need to declare the return type of the function. The return type can be any valid C++ data type, such as int, float, char, bool, or even a user-defined type.

Let's take a look at an example:

1#include <iostream>
2
3using namespace std;
4
5int add(int a, int b) {
6  return a + b;
7}
8
9int main() {
10  int num1 = 10;
11  int num2 = 20;
12  int sum = add(num1, num2);
13
14  cout << "The sum of " << num1 << " and " << num2 << " is: " << sum << endl;
15
16  return 0;
17}

In this example:

• We have a function named add that takes two integers a and b as parameters.
• Inside the function, we use the return statement to specify the sum of a and b as the return value.
• In the main function, we call the add function with the arguments num1 and num2, and we store the returned value in the variable sum.
• Finally, we use cout to display the sum of num1 and num2.

When you run the code, the output will be:

1The sum of 10 and 20 is: 30

xxxxxxxxxx

#include <iostream>

​

using namespace std;

​

int add(int a, int b) {

  return a + b;

}

​

int main() {

  int num1 = 10;

  int num2 = 20;

  int sum = add(num1, num2);

​

  cout << "The sum of " << num1 << " and " << num2 << " is: " << sum << endl;

​

  return 0;

}

Function Overloading

In C++, function overloading is a feature that allows you to define multiple functions with the same name but different parameters. This means that you can have multiple functions with the same name in the same scope, as long as they have different parameter lists.

Function overloading is useful when you want to perform the same operation on different data types or with different parameter combinations.

Here's an example of function overloading in C++:

1#include <iostream>
2
3using namespace std;
4
5// Function overloading
6int add(int a, int b) {
7  return a + b;
8}
9
10float add(float a, float b) {
11  return a + b;
12}
13
14int main() {
15  int num1 = 10;
16  int num2 = 20;
17  float num3 = 5.5;
18  float num4 = 2.5;
19
20  int sum1 = add(num1, num2);
21  float sum2 = add(num3, num4);
22
23  cout << "The sum is: " << sum1 << endl;
24  cout << "The sum is: " << sum2 << endl;
25
26  return 0;
27}

In this example:

• We have two functions named add, one that takes two integers as parameters and returns an integer, and another that takes two floats as parameters and returns a float.
• In the main function, we call the add function with different parameters.
• Depending on the parameters used, the appropriate function is called and the correct sum is calculated and displayed.

When you run the code, the output will be:

1The sum is: 30
2The sum is: 8

xxxxxxxxxx

#include <iostream>

​

using namespace std;

​

// Function overloading

int add(int a, int b) {

  return a + b;

}

​

float add(float a, float b) {

  return a + b;

}

​

int main() {

  int num1 = 10;

  int num2 = 20;

  float num3 = 5.5;

  float num4 = 2.5;

​

  int sum1 = add(num1, num2);

  float sum2 = add(num3, num4);

​

  cout << "The sum is: " << sum1 << endl;

  cout << "The sum is: " << sum2 << endl;

​

  return 0;

}

User-Defined Functions

In C++, you can create your own user-defined functions to perform specific tasks. User-defined functions allow you to break down your code into smaller, more manageable pieces that can be reused throughout your program.

When creating a user-defined function, you need to provide the following information:

• The name of the function
• The parameters (inputs) the function requires, if any
• The return type of the function, if any

Here is an example of a user-defined function that calculates the factorial of a number:

1#include <iostream>
2using namespace std;
3
4int factorial(int n) {
5  if (n == 0)
6    return 1;
7  else
8    return n * factorial(n - 1);
9}
10
11int main() {
12  int num = 5;
13  int result = factorial(num);
14
15  cout << "The factorial of " << num << " is: " << result << endl;
16
17  return 0;
18}

In this example, we have defined a function called factorial that takes an integer n as a parameter and returns an integer. The function uses recursion to calculate the factorial of the given number.

When you run the code, the output will be:

1The factorial of 5 is: 120

User-defined functions can be used to perform a wide range of tasks, from simple calculations to complex algorithms. They allow you to write modular and reusable code, improving the overall structure and maintainability of your programs.

Next, we will explore more advanced concepts related to user-defined functions, such as function overloading and function templates.

Recursion

Recursion is a powerful programming concept that involves a function calling itself. It is a technique where a problem is divided into smaller subproblems, and the function repeatedly calls itself on these smaller subproblems until a solution is reached.

Recursion is best understood through analogies. Let's consider the example of a Russian nesting doll. A Russian nesting doll consists of multiple dolls of decreasing sizes nested inside each other. Each doll resembles a smaller version of the larger doll, and the smallest doll represents the base case.

In a similar manner, a recursive function breaks down a problem into smaller, simpler versions of itself until it reaches the base case, which represents the simplest version of the problem that can be solved directly.

The base case is crucial in recursion as it defines the termination condition, preventing the function from calling itself indefinitely and causing a stack overflow.

Here is an example of a recursive function that calculates the factorial of a number:

1#include <iostream>
2using namespace std;
3
4int factorial(int n) {
5  // Base case
6  if (n == 0)
7    return 1;
8  // Recursive case
9  else
10    return n * factorial(n - 1);
11}
12
13int main() {
14  int num = 5;
15  int result = factorial(num);
16
17  cout << "The factorial of " << num << " is: " << result << endl;
18
19  return 0;
20}

In this code snippet, the factorial function calls itself with a smaller value of n until it reaches the base case where n becomes 0. This recursive approach allows us to calculate the factorial of a number by multiplying it with the factorial of the smaller number.

Recursion is commonly used in various algorithms such as tree traversal, searching, sorting, and backtracking. It provides an elegant way to solve complex problems by breaking them down into simpler subproblems.

Make sure to handle the base case correctly and ensure that the recursive call reduces the problem size, so the function eventually reaches the base case and terminates.

Recursion can be a challenging concept to grasp initially, but with practice and understanding, it becomes a powerful tool in a programmer's arsenal.

In-Built Functions

In addition to user-defined functions, C++ provides a rich set of in-built functions that can be used to perform various operations. These functions are already implemented in the C++ standard library, and you can directly use them in your code.

In this lesson, we will explore some commonly used in-built functions in C++.

Commonly Used In-Built Functions

sqrt

The sqrt function is used to calculate the square root of a number. It takes a single argument of type double or float and returns the square root as a double or float value.

1#include <cmath>
2
3int main() {
4  int num = 16;
5
6  // Using in-built function
7  double squareRoot = sqrt(num);
8
9  return 0;
10}

abs

The abs function is used to calculate the absolute value of a number. It takes a single argument of any integral type (int, long, char, etc.) and returns the absolute value as the same type.

1#include <cmath>
2
3int main() {
4  int num = -10;
5
6  // Using in-built function
7  int absoluteValue = abs(num);
8
9  return 0;
10}

max and min

The max and min functions are used to find the maximum and minimum values between two numbers, respectively. They take two arguments of the same type and return the maximum or minimum value as the same type.

1#include <algorithm>
2
3int main() {
4  int a = 5;
5  int b = 10;
6
7  // Using in-built functions
8  int maximumValue = max(a, b);
9  int minimumValue = min(a, b);
10
11  return 0;
12}

xxxxxxxxxx

#include <iostream>

#include <cmath>

​

int main() {

  int num = 16;

​

  // Using in-built functions

  int squareRoot = sqrt(num);

  int absoluteValue = abs(-10);

  int maximumValue = max(5, 10);

  int minimumValue = min(5, 10);

​

  std::cout << "Square root of " << num << " is " << squareRoot << std::endl;

  std::cout << "Absolute value of -10 is " << absoluteValue << std::endl;

  std::cout << "Maximum value between 5 and 10 is " << maximumValue << std::endl;

  std::cout << "Minimum value between 5 and 10 is " << minimumValue << std::endl;

​

  return 0;

}