###### C++ Polymorphism

C++ User Defined Function Types

# C++ User Defined Function Types

## User Defined Function Types

There can be 4 different types of user-defined functions, they are:
1) Function with no argument and no return value
2) Function with no argument but return value
3) Function with argument but no return value
4) Function with argument and return value

Below, we will discuss about all these types, along with examples.
Consider a situation in which you have to check prime number. This problem is solved below by making user-defined function in 4 different ways as mentioned above.

### 1. Function with No arguments passed and no return value

• In this type of function each function are independent.
• They need the data, data values, calculate the result and display the same block.
• These functions can either be used to display information or they are completely dependent on the user.

### Example 1: Function with No arguments passed and no return value

``````// This program to check if you are 18 or not using goto statement.

# include <iostream>
using namespace std;
void prime();
int main(){
// No argument is passed to prime()
prime();
return 0;
}

// Return type of function is void because value is not returned.
void prime(){
int num, i, a = 0;

cout << "Enter a positive integer enter to check: ";
cin >> num;

for(i = 2; i <= num/2; ++i)
{
if(num % i == 0)
{
a = 1;
break;
}
}
if (a == 1)
{
cout << num << " is not a prime number.";
}
else
{
cout << num << " is a prime number.";
}
}``````

Output 1

```Enter a positive integer enter to check: 2
2 is a prime number.```

Output 2

```Enter a positive integer enter to check: 4
4 is not a prime number.```

Working of above program

In the above program, `prime()` is called from the main() with no arguments.

`prime()` takes the positive number from the user and checks whether the number is a prime number or not.

Since, return type of `prime()` is `void`, no value is returned from the function.

## 2. Function with No arguments passed but a return value

• In this type of function the number of argument are pass through the calling function to the called function but the called function returns value.
• The variable required for the called function that are declared and initialize the same called function module. The called function is independent.

### Example 2: Function with No arguments passed but a return value

``````#include <iostream>
using namespace std;
int prime();
int main()
{
int num, i, a = 0;
// No argument is passed to prime()
num = prime();
for (i = 2; i <= num/2; ++i)
{
if (num%i == 0)
{
a = 1;
break;
}
}
if (a == 1)
{
cout<<num<<" is not a prime number.";
}
else
{
cout<<num<<" is a prime number.";
}
return 0;
}

// Return type of function is int
int prime()
{
int n;

printf("Enter a positive integer to check: ");
cin >> n;

return n;
}``````

Output 1

```Enter a positive integer enter to check: 2
2 is a prime number.```

Output 2

```Enter a positive integer enter to check: 4
4 is not a prime number.```

Working of above program

In the above program, `prime()` function is called from the `main()` with no arguments.

`prime()` takes a positive integer from the user. Since, return type of the function is an `int`, it returns the inputted number from the user back to the calling `main()` function.

Then, whether the number is prime or not is checked in the main() itself and printed onto the screen.

## 3. Function with Arguments passed but no return value

• This type of function, arguments are passed through the calling function to called function but does not returns value.
• Such type of function practically dependent on each other.

### Example 3: Function with No arguments passed but a return value

``````#include <iostream>
using namespace std;
void prime(int n);
int main(){
int num;
cout << "Enter a positive integer to check: ";
cin >> num;

// Argument num is passed to the function prime()
prime(num);
return 0;
}
// There is no return value to calling function. Hence, return type of function
is void.
void prime(int n){
int i, a = 0;
for (i = 2; i <= n/2; ++i)
{
if (n%i == 0)
{
a = 1;
break;
}
}

if (a == 1)
{
cout << n << " is not a prime number.";
}
else {
cout << n << " is a prime number.";
}
}``````

Output 1

```Enter a positive integer enter to check: 3
3 is a prime number.```

Output 2

```Enter a positive integer enter to check: 6
6 is not a prime number.```

Working of above program

In the above program, positive number is first asked from the user which is stored in the variable num.

Then, num is passed to the `prime()` function where, whether the number is prime or not is checked and printed.

Since, the return type of `prime()` is a `void`, no value is returned from the function.

## 4. Function with Arguments passed and a return value.

• This is the best type, as this makes the function compeletely independent of inputs and outputs, and only the logic is defined inside the function body.
• Both functions are dependent on each other.

### Example 4: Function with Arguments passed and a return value.

``````#include <iostream>
using namespace std;

int prime(int n);
int main(){
int num, a = 0;
cout << "Enter positive integer to check: ";
cin >> num;

// Argument num is passed to check() function
a = prime(num);
if(a == 1)
cout << num << " is not a prime number.";
else
cout<< num << " is a prime number.";
return 0;
}
/* This function returns integer value.  */
int prime(int n)
{
int i;
for(i = 2; i <= n/2; ++i)
{
if(n % i == 0)
return 1;
}

return 0;
}``````

Output 1

```Enter a positive integer enter to check: 3
3 is a prime number.```

Output 2

```Enter a positive integer enter to check: 6
6 is not a prime number.```

Working of above program

In the above program, a positive integer is asked from the user and stored in the variable `num`.

Then, `num` is passed to the function `prime()` where, whether the number is prime or not is checked.

Since, the return type of `prime()` is an `int`, 1 or 0 is returned to the `main()` calling function. If the number is a prime number, 1 is returned. If not, 0 is returned.

Back in the `main()` function, the returned 1 or 0 is stored in the variable a, and the corresponding text is printed onto the screen.

## Next Tutorial

We hope that this tutorial helped you develop better understanding of the concept of User Defined Functions Types in C++.

Keep Learning : )

In the next tutorial, you'll learn about C++ `Default Arguments`.