C++ Functions

Functions are reusable code blocks that will only execute when called. It is a section of a program that can act on data and return a value. This function can contain statements that call other functions, some of which might call others, and so on.

Advantages

A well-designed function performs a specific task. Complicated tasks should be broken down into multiple functions, which each can be called in turn. This makes your code easier to understand and maintain. It provides modularity and code reusability.

Types of Functions

There are two types of functions in C programming:

Library Functions are the the inbuilt C++ functions which are declared in the C++ header files such as ceil(x), cos(x), exp(x), etc.

User-defined functions: are the functions which are created by the programmer which is reusable. It reduces complexity of a big program and optimizes the code.

Declaration of a function

The syntax of creating C++ function is given below:

return_type function_name(data_type parameter_list...)
{  
//code to be executed  
}

The return_type specifies the type of data that the function returns. A function may return any type of data except an array. The parameter_list is a comma-separated list of variable names and their associated types that receive the values of the arguments when the function is called.

function_name(type varname1, type varname2, . . . , type varnameN)

For example, here are correct and incorrect function parameter declarations:

f(int i, int k, int j) /* correct */
f(int i, k, float j) /* incorrect */

A function may be without parameters, in which case the parameter list is empty.

void myFunction()
{
cout << "Hello World";
}

Let's see the simple example of C++ function.

#include <iostream>
using namespace std;
void func() {  
   static int i=0; //static variable  
   int j=0; //local variable  
   i++;  
   j++;  
   cout<<"i=" << i<<" and j=" <<j<<endl;  
}  
int main()
{
 func();  
 func();  
 func();  
}

Calling Functions

The function above will simply print out a text message when it is called. To invoke it from the main function the function's name is specified followed by a set of parentheses.

void myFunction()
{
cout << "Hello World";
}

int main()
{
myFunction(); // "Hello World"
}

Function Arguments/ Parameters

The parentheses that follow the function name are used to pass arguments to the function in the form of comma separated list. To use arguments, it must declare variables that accept the values of the arguments. These variables are called the formal parameters of the function.

void myFunction(string a, string b)
{
cout << a + " " + b;
}

A function can be defined to take any number of parameters, and they can have any data types. Just ensure the function is called with the same types and number of arguments.

myFunction("Hello", "World"); // "Hello World"

Default Function Parameters

We can specify default values for parameters by assigning them a value inside the parameter list.

void myFunction(string a, string b = "Earth")
{
cout << a + " " + b;
}

If that argument is unspecified when the function is called the default value will be used instead. When a function has more than one parameter, default values are assigned based on the order of the parameters.

myFunction("Hello"); // "Hello Earth"

If a parameter does not have a default value, parameter may have a default value.

Here’s a prototype with four parameters:

long set4DPoint(int x, int y, int z, int t); //Valid

long set4DPoint(int x, int y, int z = 1, int t); //Invalid

Returning from Function

Functions return a value or void, a data type that represents a nonvalue in C++.

To return a value from a function, the keyword return is followed by the value to return. The value can be a literal, a variable, or an expression, because all expressions produce a value.

Here are some examples

return 5;
return (x > 5);
return (convert(fahrenheit));

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

The return is a jump statement that causes the function to exit and return the specified value to the place where the function was called.

cout << getSum(5, 10); // 15

The return statement can also be used in void functions to exit before the end block is reached.

void dummy() { return; }

int main() { return 0; }

Inline Functions

When using functions, every time a function is called, a performance overhead occurs. To remove this overhead you can recommend that the compiler inlines the calls to a specific function by using the inline function modifier. This keyword is best suited for small functions that are called inside loops.

inline int myInc(int i) { return i++; }