Suppose you were writing a program that needed to use a square root. (For readers whose maths is rusty, the square of a number is what you get when you multiply the number by itself. So, for example, the square of 4 is 16. A square root is the opposite. The square root of some number x is that number which, when multiplied by itself, gives you x. So the square root of 16 is 4.)
If the square root is an integer, as in my example, the arithmetic is not too hard. But if the square root is a number with a decimal point in it (a "floating-point number"), it's not so easy. What is the square root of 15? Three point something, but what exactly?
The data types we have looked at so far include integers, strings and booleans (in C++ int, string and bool). For doing calculations involving decimal points, we use a data type called a double. There is also a data type called a float (for "floating-point number"), which we could also use. A double occupies twice as much memory as a float, hence its name. In the days when a computer's memory was very limited, you would use a double only if you needed the extra precision, but, now that computer memories are so much larger than they used to be, the double is more often used. In C++ it is the default for representing floating-point numbers. That is to say, if you had an assignment such as d = -0.23; the -0.23 would, technically, be a double, not a float.
Fortunately, we do not have to invent our own algorithm for calculating square roots since C++ provides a square-root function. If we #include <cmath> then we can use a function called sqrt. For example, we could say double d = sqrt(15.0); or cout << sqrt(15.0); (It's 15.0, a double, rather than 15, an int, since the sqrt function expects to be given a double.)
The sqrt function is one of the functions in the cmath library. That is to say, it is a self-contained unit of program code, placed in one of the standard libraries, which is there for us to use if we want to. It takes number (as a double) and returns a double representing the square root of that number. In the example, we give it (or pass it) the number 15.0, and it gives us back (or returns) 3.87298.
Note that we do not know how it does what it does, and we do not need to know. To us, it is a "black box". To use it, we just need to know its name (sqrt), what it takes (a double) and what it returns (also a double). (We also need to know that it is in the cmath library and to remember to #include <cmath>. This is one of the nuisances of the library system.)
If we had two variables of type double, d1 and d2, we could say d1 = sqrt(d2); In this case the value of d2 is passed to the sqrt function. Or we could say d1 = sqrt(d2/3.7); or d1 = sqrt(d2/3.7 * 5.4 + 8.913);. The expression in the brackets (which is known as the argument) is evaluated, and its value is passed to the sqrt function.
Using a function is known as calling a function; sqrt(d2) is an example of a function call.
With square-roots, we were in luck; the C++ language designers had decided to include a square-root function in the standard library. But what if we need a function that is not provided in the library? Then we write our own.
Suppose we want a square function; square(x) will return x * x. You may feel that we hardly need a function for this since writing, say, double d2 = square(d1); is no easier than writing double d2 = d1 * d1; But suppose it's
double d3 = square(d1/3.706 * (d2/9.854 + 4.6));
double d3 = (d1/3.706 * (d2/9.854 + 4.6)) * (d1/3.706 * (d2/9.854 + 4.6));
square function might actually be useful.
The first thing we have to decide, in writing the square function, is what type of function it is, i.e. what type of thing it is going to return. It's clear from the examples above that the square function is going to return a double, so that is the first thing we write down when defining the function.
Next we have to think of a good name for it. I've already done that in calling it square.
Now we have to decide what we are going to pass to it when we call it — the things that it needs to be given (if any) to do its job. In the case of square, this is simple; it needs a double. We can now write the first line of the function definition:
double square(double dx)
square that takes a double [that's the part in brackets] and also returns a double [that's the first word on the line]."
The thing in brackets, that I have called dx, is a parameter. It is declared like a variable — a type name followed by an identifier — and it behaves like a variable within the function.
Its purpose is to receive the value that gets passed when the function is called. I'll come back to that in a second. First let's complete the function definition.
We have written the first line, sometimes called the function header. Now we write the body of the function; this is where we specify what the function does. Since the purpose of a function is to return a value, we need to calculate the value to be returned. We do this in an ordinary block of code and return it with the keyword return. (A block, you will recall, is some lines of program code between curly braces.) We could do it like this:
double square(double dx)
{ double lv;
lv = dx * dx;
return lv;
}
lv is an example of a local variable i.e. a variable that is accessible only within the function. The parameter dx also behaves like a local variable. The difference is that, whereas the value of the local variable lv is initially undefined (unless we choose to initialize it), the parameter dx will already have been given a value by the time this code executes.
Suppose that our function is called in the following way:
int main()
{ double d1 = 1.5;
cout << "The square of " << d1 << " is " << square(d1) << "." << endl;
}
square(d1) it evaluates the argument, i.e. it works out that the current value of d1 is 1.5, and then passes this value to the function. This value is then used to initialize the parameter dx. So, by the time the body of the function begins to execute, dx already has the value 1.5. The function body then evaluates dx * dx (i.e. multiplies 1.5 by 1.5), assigns the result (2.25) to be the value of lv and then returns the value of lv. So the value of the expression square(d1) is 2.25, and the program's output is, "The square of 1.5 is 2.25."
The process by which a value is passed to the function and becomes the initial value of the parameter is known as parameter passing. This is the standard term though actually it is slightly odd since it's really the argument, or rather the value of the argument, that gets passed; the parameter is on the receiving end. When writing a function, bear in mind that, when your function code executes, the parameters will already have values. You don't have to do anything (for example with cin >>) to put values into them; they already have values thanks to the parameter passing.
Note that the argument does not have to have the same name as the parameter. Equally, it would not matter if it did. The argument and the parameter are two different entities. It is the mechanism of parameter passing that links them, not their names.
Returning to our square function, we can simplify it. The local variable is not really necessary, and we could write the function more simply as follows:
double square(double dx)
{ return dx * dx;
}
It only remains to say where the function definition goes in relation to the other parts of the program. For now, it will be simplest to put it after the using namespace std; and before the int main(). So, the whole program looks like this:
#include <iostream>
using namespace std;
double square(double dx)
{ return dx * dx;
}
int main()
{ double d1 = 1.5;
cout << "The square of " << d1 << " is " << square(d1) << "." << endl;
}
#include <iostream>
using namespace std;
double square(double dx)
{ return dx * dx;
}
int main()
{ double d1 = 1.5, d2 = 10.1;
cout << "The square of " << d1 << " is " << square(d1) << "." << endl;
cout << "The square of " << d2 << " is " << square(d2) << "." << endl;
cout << "The square of " << d1 + d2 << " is " << square(d1 + d2) << "." << endl;
cout << "The square of " << square(d1) << " is " << square(square(d1)) << "." << endl;
}
Write a function, called triplus (just the function definition, not the call or any of the rest of the program) that takes an int as its parameter and returns that number times three plus one. If the call was triplus(3) it would return 10; for triplus(8) it would return 25.
To check your answer, click on Answers to the exercises.
We can also have strings, both as parameters and as return types. The following is a function that takes a string as its parameter and returns the last character. For example, if place was a string with the value "Hornby", last(place) would return the single-character string "y".
string last(string s)
{ return s.substr(s.length()-1); // or return s.substr(s.length()-1, 1);
}
Sometimes the function needs more than one thing to do its job. If, for example, we wanted a function that returned the longer of two strings (or either if they are the same length), it would have to have two parameters, and we would write them in a comma-separated list, each one with its data type:
string longer(string a, string b)
{ if (a.length() > b.length())
return a;
else return b;
}
string one = "Quernmore", two = "Abbeystead";
string three = longer(one, two);
string firstpart(string s, int n)
{ return s.substr(0, n);
}
place variable held the string "Ulverston", then firstpart(place, 5) would return the value "Ulver". Note that the order of the arguments has to match the order of the parameters (in this case, a string first followed by an int).
Note also that you have to state the data type for each parameter in a parameter list, even if they are all the same. For example, a function that took three integers as its parameters and returned an integer would have a header something like this:
int func(int a, int b, int c)
longer above, returns the length of the longer string:
int longer_length(string a, string b)
{ if (a.length() > b.length())
return a.length();
else return b.length();
}
Change our last function into a lastpart function that returns the last n characters of a string. For example if place held the value "Cartmel", lastpart(place, 3) would return "mel". See if you can modify it further so that, if the value of n is longer than the string (such as lastpart(place, 10) for "Cartmel") it returns the full string.
To check your answer, click on Answers to the exercises.
All the functions we have seen so far return a value. That is what they are for. But it is possible, in C++, to write a function that returns no value. You call such a function, not for what it returns (it returns nothing), but for what it does. Some other languages draw a distinction between functions (that return values) and procedures (that don't). In C++, both are called functions; it's just that some functions return no value. But I find it helpful to keep the term "procedure"; by "procedure" I simply mean "void function".
You begin the definition of one of these with the word void as the return type. For example, we could write a procedure (void function) to take a string and to write it out with a few stars to left and right:
void stars(string s)
{ cout << "*** " << s << " ***" << endl;
}
stars("Urgent");
*** Urgent ***
A (non-void) function call is an expression, something that gets evaluated and returns a value, such as d2 = square(d1); or if (sqrt(d) > 20.0) or cout << lastpart(place, 3); By contrast, a call to a void function is a statement, such as stars("Urgent"); This is how it might look in a program:
#include <iostream>
#include <string>
using namespace std;
void stars(string s)
{ cout << "*** " << s << " ***" << endl;
}
int main()
{ string message = "This is important.";
stars(message);
}
#include <iostream>
#include <string>
using namespace std;
string starred(string s)
{ return "*** " + s + " ***";
}
int main()
{ string message = "This is important.";
cout << starred(message) << endl;
}
main simply hands over a message to stars, and stars both adds the stars and outputs it. In the second, main asks starred to return a new version of the message, with added stars, and then main itself takes care of the outputting.
Which is better? For these tiny programs, it hardly matters. In the context of a larger program, it would depend on what else the program wanted to do with these starred messages. If it had various messages and sometimes output starred versions but sometimes did something else with a starred version, such as assigning it to be the value of another string:
string urgent_message = starred(message);
In the examples we have seen so far, it has always been main that did the calling. But in fact it is possible for one function to call another. This enables us to have a third version:
#include <iostream>
#include <string>
using namespace std;
string starred(string s)
{ return "*** " + s + " ***";
}
void out_starred(string s)
{ cout << starred(s) << endl;
}
int main()
{ string message = "This is important.";
out_starred(message);
}
starred function first, then the out_starred procedure, and then main.
Although procedures and functions generally have parameters, they don't have to. In other words, the parameter list can be empty. This procedure just outputs the string "Ouch!" whenever it is called:
void ouch()
{ cout << "Ouch!";
}
ouch();
The most obvious difference between a procedure definition and a (non-void) function definition is that the former begins with the word void. But there is another. A (non-void) function always contains a return whereas a procedure does not have to. If there is no return in a procedure, it will simply execute and then the flow of program control will return to the line after the call. For example:
#include <iostream>
using namespace std;
// Assume that the first and last functions are defined here
void test_and_display(string s)
{ cout << "The string is " << s << endl;
cout << "The length is " << s.length() << endl;
cout << "The first character is " << first(s) << endl;
cout << "The last character is " << last(s) << endl;
// Control is returned from here.
}
int main()
{ string userstring;
cout << "Please key in a string: ";
cin >> userstring;
test_and_display(userstring);
// Control is returned to here.
cout << "Thank you and goodbye" << endl;
}
return if you want. Of course, this is not like return dx * dx; or return a.length(); because a void function does not return anything. It is simply return; You might use this if, in some circumstances, you did not want the procedure to execute in full. For example, the test_and_display procedure would crash or produce peculiar output if it was given an empty string (a string of length zero, i.e. with no characters at all). We could prevent this by inserting some lines:
void test_and_display(string s)
{ if (s.length() == 0)
{ cout << "Empty string." << endl;
cout << "Zero length, no characters." << endl;
return; // Either control is returned from here
}
cout << "The string is " << s << endl;
....
// Or control is returned from here.
}
else:
void test_and_display(string s)
{ if (s.length() == 0)
{ cout << "Empty string." << endl;
cout << "Zero length, no characters." << endl;
}
else
{ cout << "The string is " << s << endl;
....
}
// Control is returned from here.
}
Write a procedure (void function) that takes two integers and displays the sum, the difference (the larger minus the smaller), the product, the quotient (the larger divided by the smaller) and the remainder. For example, if given 13 and 5 (or 5 and 13), it would output the following:
The sum is 18.
The difference is 8.
The product is 65.
The quotient is 2, remainder 3.
To check your answers, click on Answers to the exercises.
main function
In most respects, main is an ordinary function. As you can see from its header — int main() — it has an empty parameter list and returns an int. (Actually, it can have parameters, but that takes us beyond this introductory lesson.) But, if it's a function, where is the function call? Where does main get called from? It gets called from the operating system, the program (Windows, Unix or whatever) that is running all the time a computer is switched on and which gives it its basic repertoire of behaviour — maintaining the screen display, managing the file storage system and so on. When main calls, for example, test_and_display, it hands over control to the function and waits till it returns. In much the same way, when the operating system calls main, it hands over control to your program and waits till main returns, i.e. until your program terminates.
Since main is an int function, it returns an int at the end, to the operating system. In some operating systems, Unix for example, it is possible to chain a series of programs together, each one passing on the results of its work to the next one. When one has finished, the operating system calls the next. In such a system, it is very useful for the individual programs to be able to signal to the operating system whether they were able to do their part successfully or whether something went wrong, in which case the whole chain of processing should be aborted. The integers returned from main can be used for that. By convention, a return value of zero from main means "Everything OK" and any other value means "Something went wrong." Since things can go wrong in different ways, it is possible to arrange for different return values to have different meanings.
It will not have escaped your notice that not one of the main functions that we have had so far in these notes appears to return anything. Should we not be returning an int since it's an int function? We could, if we wanted, put a return 0; as the last line of main (if we were programming in C, rather than C++, it would be obligatory), but we don't have to. If we leave it out, the compiler puts it in for us. This is another respect in which main differs from other functions. With all other (non-void) functions, an explicit return is essential; with main, you can leave the compiler to put it in for you.
Returning from main allows us to terminate the program in a simple way. If something goes wrong such that there is no point in continuing the program (if, for example, we tried to read in a file of data but could not find it), we can terminate simply with, say, return 1; (1 for "something's wrong" rather than 0 for "all's well"). Note, however, that it is only when we are in main that we can terminate the program with a return. If we are in any other function, a return will simply terminate that particular function.
Write a function that takes a string as its parameter. If the string has fewer than three characters, it returns an empty string. Otherwise it returns the middle section of the string, i.e. the string minus its first and last characters. For example, if it was passed the string "Kendal", it would return "enda".
Write a procedure (void function) that takes a string as its parameter. If the string is empty, it does nothing. If the string has only one character, it outputs that character followed by a newline character. Otherwise it outputs the characters separated by spaces, with a newline on the end. For example, if it was passed the string "Carnforth", it would output:
C a r n f o r t h
Copying the firstpart function (above) into your program in the right place, write a program that takes a string from the user and then, using a loop and using firstpart, writes out a triangle of letters based on that string. For example, if the user keyed in the name "Morecambe", the computer would display the following:
M
Mo
Mor
More
Morec
Moreca
Morecam
Morecamb
Morecambe
To check your answers, click on Answers to the exercises.