(C++) Subroutines: procedures and functions - 1

Subroutines

Using subroutines allows you to avoid code duplication, if you need to write the same code in different places in the program. 
Libraries that are imported into the program (for example, the mathematical library сmath.h) consist of subroutines that have already been compiled by someone. Programmers do not need to think about what algorithms they implement, but simply apply them, thinking only about what exactly they are doing. This is a big time saver. There is no need to write an algorithm that has already been written by someone else.

Each routine should only do one task,  either just calculate something, or output some data, or do something else. 

Subroutines are of two types - procedures and functions.

Subroutines perform some actions, for example, display the result on the screen in a certain form (a simple example, the operator printf()  is a standard subroutine that prints information to the screen)

Function subroutines return a result (number, character string, etc.) that we can use in the main program.

Let's try to write a simple procedure:
Suppose we want to display the string "Error" every time an error can occur in the code due to the fault of the user (for example, when he enters incorrect data)
This can be done by writing the operator cout << "Error"; And now imagine that such a line needs to be inserted in many places in the program. Of course, you can just write it everywhere. But this solution has two drawbacks.
1) this string will be stored in memory many times
2) if we want to change the output on error, we will have to change this line throughout the program, which is rather inconvenient

For such cases, procedures are needed.
A program with a procedure might look like this: #include<iostream> using namespace std; void printError() // procedure description { cout << "Error"; // procedure body - commands that the procedure will execute } main() { ... printError() // start the procedure for execution. We just specify the name of the procedure we want to execute. ... printError() ... } The procedure begins with the word void. There are empty brackets after the procedure name.
All statements that are executed in a procedure are indented. 

Procedures are written before the main function main()

To execute a procedure, in the main program you need to call it by name and remember to write parentheses!
You can call a procedure in a program any number of times.

Now let's imagine that we need to display different messages in response to a user's error, depending on what kind of mistake he made.
In this case, you can write your own procedure for each error:   void printErrorZero() { cout << "Error. Division by zero!"; } void printErrorInput() { cout << "Error in input!"; } What if there are many more possible errors? This solution will not suit us!
We need to learn how to control the procedure by telling it what error message to display.
To do this, we need parameters that we will write in parentheses after the procedure name void printError(strings) { cout << s; } In this procedure, s is a parameter - a special variable that allows you to control the procedure.

The parameter is a variable that determines how the subroutine works. Parameter names are listed separated by commas in the subprogram header. The parameter type is written before the parameter.

Now, when calling the procedure, you need to indicate in brackets the actual value that will be assigned to the parameter (variable s) inside our procedure printError("Error! Division by zero!"); Such a value is called an argument.

The argument is the parameter value that is passed to the subroutine when it is called.

An argument can be not only a constant value, but also a variable or an arithmetic expression.

Local and global variables

It is often necessary to use additional variables that will only be used in the subroutine. Such variables are called local (or local) and can only be manipulated within the subroutine in which they are created.
 
The main program in C++ is also a subroutine, so all variables declared inside main() are local variables.
Other subroutines don't "know" anything about the local variables of other subroutines.

Thus, it is possible to limit the scope (scope) of a variable only to the subroutine where it is really needed. In programming, this technique is called encapsulation  - hiding a variable from being changed from outside.

If it is necessary to declare a variable that would be visible anywhere in the program (in any subroutine), then such variables are declared outside of all subroutines (see program 3 from the table below).
Such variables are called global.

In C++, when the program starts, all global variables are automatically set to zero (boolean variables take the value false).


Analyze three programs: is displayed on the screen

1) In this program, the variable i is local. A local variable is declared inside a subroutine	2) Here, even if there is a variable i in the main program (with value 7), a new local variable i with value 5 will be created.  When you run this program, the screen will display the value 75	3) This program has a global variable i. Its value can be changed inside a subroutine, and inside the main program The procedure will work with the global variable i and it will be assigned a new value equal to 2. The value 2
void test() {   int i = 5; cout << i; }	void test() {   int i = 5;   cout << i; } main() { int i = 7;   cout << i;   test(); }	#include <iostream> using namespace std; int i; void test() {   i = 2; } main() { test(); cout << i; }

Task

Write a procedure that swaps the values ​​of two variables.

The peculiarities of this task are that we need the changes made in the procedure to become known to the calling program.

Let's try to write the procedure like this: void Swap ( int a, int b ) // with such a description of the procedure parameters, { // the values ​​of the arguments (x and y) will be copied, int c; // variables a and b are independent variables not related to x and y c = a; a = b; b=c; } main() { int x=1, y=2; Swap(x, y); // values ​​of variables x and y (arguments) are copied into parameters a and b cout << "x=" << x<< ", y=" << y; // x=1, y=2 } If you run this program, you can see that the values ​​of the variables x and y have not changed. In order for the parameters to change the values ​​of the arguments, you must use passing data by reference. To do this, after the name of the data type in the header of the subroutine, you must put the sign & ("ampersand"). void Swap ( int & a, int & b ) // now variables a and b get addresses of variables x and y in memory { int c; c = a; a = b; b=c; } Usage: If you pass an argument by reference, then only the variable name (NOT a number and NOT an arithmetic expression) can be in this place when calling the procedure!

DO NOT call a procedure like this: Swap(x, 4 ); Swap(5+x, y);