Functions in C++

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++:

#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;
}

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:

The result is: 15

```c++
#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;
}
```

A function definition in C++ consists of a declaration and a definition.

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:

#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;
}

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!

```c++
#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;
}
```

Which of the following best describes a parameter in a function?

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:

#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;
}

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:

The sum of 10 and 20 is: 30

```c++
#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;
}
```

The return value of a function in C++ is specified in the function's declaration.

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++:

#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;
}

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:

The sum is: 30
The sum is: 8

```c++
#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;
}
```

Which of the following is NOT a benefit of function overloading in C++?

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:

#include <iostream>
using namespace std;

int factorial(int n) {
  if (n == 0)
    return 1;
  else
    return n * factorial(n - 1);
}

int main() {
  int num = 5;
  int result = factorial(num);

  cout << "The factorial of " << num << " is: " << result << endl;

  return 0;
}

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:

The 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.

In C++, user-defined functions allow you to break down your code into smaller, more manageable pieces that can be ______________ throughout your program.

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:

#include <iostream>
using namespace std;

int factorial(int n) {
  // Base case
  if (n == 0)
    return 1;
  // Recursive case
  else
    return n * factorial(n - 1);
}

int main() {
  int num = 5;
  int result = factorial(num);

  cout << "The factorial of " << num << " is: " << result << endl;

  return 0;
}

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.

Which of the following best describes the base case in recursion?

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.

#include <cmath>

int main() {
  int num = 16;

  // Using in-built function
  double squareRoot = sqrt(num);

  return 0;
}

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.

#include <cmath>

int main() {
  int num = -10;

  // Using in-built function
  int absoluteValue = abs(num);

  return 0;
}

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.

#include <algorithm>

int main() {
  int a = 5;
  int b = 10;

  // Using in-built functions
  int maximumValue = max(a, b);
  int minimumValue = min(a, b);

  return 0;
}

```c++
#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;
}
```

Which function is used to calculate the square root of a number in C++?

Generating complete for this lesson!