C++ Function with Example | Source Code Project

C++ Operate

Capabilities are used to supply modularity to a program. Creating an utility utilizing perform makes it simpler to know, edit, verify errors and so on.

Syntax of Operate

<i>return-type</i> <b>function-name</b> (<i>parameters</i>){ // function-body}

1	<i>return-type</i> <b>function-name</b> (<i>parameters</i>){ // function-body}

return-type : suggests what the perform will return. It may be int, char, some pointer or perhaps a class object. There may be capabilities which doesn’t return something, they’re talked about with void.
Operate Identify : is the identify of the perform, utilizing the perform identify it’s referred to as.
Parameters : are variables to carry values of arguments handed whereas perform is named. A perform might or might not include parameter listing.

void sum(int x, int y){ int z; z = x + y; cout << z;}int predominant(){ int a = 10; int b = 20; sum (a, b);}

1

void sum(int x, int y){ int z; z = x + y; cout << z;}int predominant(){ int a = 10; int b = 20; sum (a, b);}

Right here, a and b are despatched as arguments, and x and y are parameters which can maintain values of a and b to carry out required operation inside perform.
Operate physique : is he half the place the code statements are written.

Declaring, Defining and Calling Operate

Operate declaration, is completed to inform the compiler concerning the existence of the perform. Operate’s return kind, its identify & parameter listing is talked about. Operate physique is written in its definition. Lets perceive this with assist of an instance.

#embody < iostream>utilizing namespace std;int sum (int x, int y); <span style="color: blue;">//declaring perform</span>int predominant(){ int a = 10; int b = 20; int c = sum (a, b); <span style="color: green;">//calling perform</span> cout << c;}int sum (int x, int y) <span style="color: blue;">//defining perform</span>{ return (X + y);}

#embody < iostream>utilizing namespace std;int sum (int x, int y); //declaring performint predominant(){ int a = 10; int b = 20; int c = sum (a, b); //calling perform cout << c;}int sum (int x, int y) //defining perform{ return (X + y);}

Right here, initially the perform is declared, with out physique. Then inside predominant() perform it’s referred to as, because the perform returns sumation of two values, therefore z is their to retailer the worth of sum. Then, ultimately, perform is outlined, the place the physique of perform is talked about. We will additionally, declare & outline the perform collectively, however then it must be finished earlier than it’s referred to as.

Calling a Operate

Capabilities are referred to as by their names. If the perform is with out argument, it may be referred to as straight utilizing its identify. However for capabilities with arguments, we now have two methods to name them,

Name by Worth
Name by Reference

Name by Worth

On this calling approach we cross the values of arguments that are saved or copied into the formal parameters of capabilities. Therefore, the unique values are unchanged solely the parameters inside perform adjustments.

void calc(int x);int predominant(){ int x = 10; calc(x); printf("%d", x);}void calc(int x){ x = x + 10 ;}

1	void calc(int x);int predominant(){ int x = 10; calc(x); printf("%d", x);}void calc(int x){ x = x + 10 ;}

Output : 10

On this case the precise variable x isn’t modified, as a result of we cross argument by worth, therefore a replica of x is handed, which is modified, and that copied worth is destroyed because the perform ends(goes out of scope). So the variable x inside predominant() nonetheless has a worth 10.

However we are able to change this program to switch the unique x, by making the perform calc() return a worth, and storing that worth in x.

int calc(int x);int predominant(){ int x = 10; x = calc(x); printf("%d", x);}int calc(int x){ x = x + 10 ; return x;}

1	int calc(int x);int predominant(){ int x = 10; x = calc(x); printf("%d", x);}int calc(int x){ x = x + 10 ; return x;}

Output : 20

Name by Reference

On this we cross the tackle of the variable as arguments. On this case the formal parameter may be taken as a reference or a pointer, in each the case they may change the values of the unique variable.

void calc(int *p);int predominant(){ int x = 10; calc(&x); // passing tackle of x as argument printf("%d", x);}void calc(int *p){ *p = *p + 10;}

1	void calc(int p);int predominant(){ int x = 10; calc(&x); // passing tackle of x as argument printf("%d", x);}void calc(int p){ p = p + 10;}