Pre-Defined Functions

Functions can be thought of as containers that contain code inside them. You have been using only one function in all programs written so far, called the main function. This was ok, as all the programs you wrote were relatively small. However, imagine if you need to write larger programs that contain hundreds or even thousands of lines of code. These programs will be very hard to review, debug, and modify. That is the reason why you must think of your code as built of various small pieces.

This way of thinking will perfectly match the algorithmic way of thinking. When you first write an algorithm to solve a certain problem, usually every task or step in the algorithm is translated into one function. In this chapter, you will learn to write and call many more functions called user-defined functions. Nevertheless, many other functions are already written and available for us to use right away, called pre-defined functions. These functions are saved in larger containers called libraries.

All functions written in C++ follow the same format:

returnType functionName(parameterType parameterName) {
//body of the function
}

To use functions correctly (either pre-defined or user-defined), you must understand very well the types of parameters^[1] (if any), the function expects to have, and the returned type as well. If a function is defined to accept a string parameter, but you call it with a numeric type, like int or double, an error message will be thrown. Similarly, knowing the returned type of a function is important because, generally, you need to declare a variable to hold the returned value. For example, if you call a function that returns a char type, you must declare a variable with the same type to save the returned value.

Functions can have zero or more parameters included inside the parentheses that appear after the function name.  If a function takes more than one parameter, a comma must be used to separate the parameters from each other. Example 3 shows this case. Every parameter added must be preceded with it is type. Additionally, functions must have a return type except if it does not return any value. In this case, the return type must be replaced by the keyword void. This topic will be discussed further in the upcoming section.

Table 1 shows some common pre-defined functions and their corresponding libraries. From the Table, you can learn that to call a function, you must use the parentheses associated with its name. These parentheses are used to pass any needed arguments^[2]. Later in this chapter, when you start defining your own functions, you will notice that most functions need more information passed to them as arguments to perform their desired operations. Some functions do not need any arguments to work; however, it is still required to write empty parentheses associated with the name of the function. This is particularly important for the compilers to distinguish between the function name from any other variable name in the code.

Unsigned Types:

Notice in Table 1, srand function expects an unsigned int as the argument type. In C++, unsigned types are integer types that can only represent non-negative numbers. This is in contrast to signed types, which can represent both positive and negative numbers. The keyword unsigned is used to declare unsigned types.

Table 2 compares the common signed and unsigned types in C++ along with their corresponding ranges. One advantage of using unsigned types is that to provide larger ranges whenever you need such a large range to solve problems.

To understand how unsigned types can provide larger ranges, we can recall that numbers are represented in computer memory as binary numbers. That is, if we have only 1-bit to represent numbers, then we can only represent two numbers, namely 0 and 1. If we choose to use 2-bits, then we can have four numbers, 00, 01, 10, and 11. By noticing the pattern, we can see that the number of possibilities equals 2n, where n is the number of bits used. For example, in Table 2, when raising 2 to the power of 8 bits, you will get the range of numbers available for the unsigned char type (notice that we start counting from 0). Similarly, you can calculate the range for unsigned int and long int by raising 2 to the power of the corresponding number of bits. On the other hand, signed types need to take one bit to represent the sign (usually 0 means positive and 1 means negative). That is, in the case of a signed char, 1 bit will be used to represent the sign, leaving 7 bits to represent the range; hence, the range now will split into two halves. One half represents the positive range starting from 0, and the other half represents the negative range. Similarly, for the signed int and long int, you can recalculate the range after taking away 1 bit to represent the sign and raising 2 to the power of the remaining bits.

rand function is used to generate pseudorandom numbers, which means not real random numbers. Random number generators use mathematical formulae to calculate these numbers; hence, they are predictable. However, their use is generally acceptable in many applications since pseudorandom numbers have statistical properties similar to true random numbers. Random number generators use a seed value to generate random numbers, which results in a specific set of random numbers for every seed value selected. If you need to generate a different set of random numbers every time a program runs, you need to find a way to randomly choose different seeds. Example 2 explains how you can do that.

User-Defined Functions

Writing functions in C++ involves two steps: function declaration and definition.  You can not use a function before it has been declared and defined. Otherwise, the compiler will complain that it is not able to execute the called function.  Another restriction is that you cannot define a function inside another function. That is, every function must be declared and defined independently from any other function.  There are two methods to declare and define functions.

Method 1:

First, you have to declare the function prototype above the main function. The function is called a prototype at this point because it is still not functional. The function still needs to be defined.

Second, define the function by writing all necessary code inside the body of the function below the main function.

The following code is the complete example code. Note the positions where the average function is declared and then defined. Once the new function is declared and defined, it is now ready to be called. You can call functions in a similar manner to how you would call any other variable name. Lines 9, 11, and 13 show several ways to call the average function. It is important here to visualize how the code is executed. When you run this code, the execution will start from the beginning until it reaches line 9. When the average function is called, the execution will jump to the definition of the function in line 19 and execute its body. When the function completes its execution, the execution will go back to line 9, where it was exactly stopped, and continue from there. The same process happens when the function is called again in lines 11 and 13.

Method 2:

If you really do not like to declare functions and then define them, it is possible to immediately define functions above the main function without the need to declare them first.

Preconditions and Postconditions

Writing meaningful comments is one of the essential skills in software engineering. For first-time programmers, it is an even more crucial skill to focus on and practice. Therefore, in this book, you will frequently be asked to provide appropriate comments in the code. In Chapter 2, preconditions and postconditions comments were introduced and are reemphasized here. In these comments, programmers describe what functions expect to receive and what they are expected to return. If they are well-written, you can use the function confidently without issues because you know how to work with the function. Writing well-formatted comments is a very common practice in designing and developing software.

Numeric Functions

Functions can be written to satisfy almost any need or requirement. In this section, the focus will be on functions that perform a set of calculations and return the result back to the caller.

In example 4,  you have written the precondition and postcondition for the square root function. Let us now develop the code for it. Calculating the square root of a positive number can be done through various algorithms. Here we will use a simplified algorithm called the Babylonian Algorithm. This algorithm iteratively approximates the square root. Note that this iterative method is an approximation and may not provide the exact square root.

In example 5,  you have written the precondition and postcondition for the factorial function. Let us now develop the code for it.

Test the provided code for several n values like 5, 10, and 20. What do you notice?! This code will be able to provide accurate results up to factorial 12. If you entered values for n larger than 12, surprisingly, you will get unreasonable results, like either negative numbers or zero! The problem here comes from the int type that, in most C++ implementations, has a size of 4 bytes (32 bits).

This means that any variable declared with the int type will be capable of holding integers ranging from -2,147,483,648 to 2,147,483,647. This range represents the positive and negative values that can be stored in a signed 32-bit integer using two’s complement representation. The most significant bit is used to represent the sign of the number, leaving 31 bits for the magnitude. Therefore, for n > 12, the code will cause a memory overflow, resulting in unexpected outcomes.

There are some specialized libraries that can help in solving this problem. However, here we can partially solve this problem with a larger type than int, which is long long int. This type uses 8 bytes to be saved in the memory and can hold numbers ranging from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807.

Boolean Functions

Some functions are designed to help us in making decisions. Rather than including the needed logic in the main function, for clarity, we can delegate this job to another function to do so. Study the following examples and notice how Boolean functions can be used mainly as testing functions.

bool isEven(int num) {
    return num % 2 == 0;
}

bool isVowel(char ch) {
    ch = tolower(ch);
    return ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u';
}

void Functions

void functions are a special type of functions that do not return any value back to the caller. However, to comply with the compiler requirements, we must add the keyword void as a placeholder in place of the regular type. void functions are useful when your needs are basically performing actions rather than calculations.

Note in example 10 that void functions do not have a return statement. This makes sense as void functions are not supposed to return any values. However, adding the return statement does not cause errors. Additionally, if the user enters their full name or full name with a middle initial, the code will only print out the first name. This is because the stream extraction operator >> reads input until a whitespace is encountered, effectively using spaces to separate different values. If you want to read everything the user enters, you can replace the code cin >> name; with getline(cin, name);. The predefined getline function reads the entire line and saves it in the name variable. Be sure to include the <string> library to be able to use this function.

Wrap up!

In this chapter, you’ve delved into the world of functions in C++, exploring both pre-defined and user-defined functions. You’ve learned that functions serve as containers for code, allowing for better organization and reusability in your programs. With user-defined functions, you can break down complex tasks into smaller, manageable pieces, enhancing readability and maintainability. Pre-defined functions, housed in libraries, provide a wealth of functionality ready for use in your programs. You’ve gained an understanding of function syntax, including parameters, return types, and function prototypes. Additionally, you’ve explored Boolean functions for decision-making and void functions for actions without return values. Through exercises and examples, you’ve honed your skills in writing, declaring, and calling functions, setting the stage for more advanced programming concepts ahead. As you continue your journey in C++, remember that functions are powerful tools in your programming arsenal, empowering you to write clear, efficient, and scalable code.

Answers Key

Exercise 01:

Exercise 02:

Exercise 03:

Exercise 04:

Exercise 05:

In C++, a function declaration, also known as a function prototype, provides the compiler with information about the function’s name, return type, and parameters. It does not include the function’s body. A function declaration typically appears at the top of a source code file.  However, a function definition includes both the function’s prototype and its body. The body of the function contains the statements that define what the function does. A function definition typically appears at the bottom of a source code file.

Exercise 06:

1.

Exercise 07

The modified code will calculate n! correctly up to n = 20 on my system.

Exercise 08:

Exercise 09:

bool isFiveDigits(string num) { 
	bool result = true;
	if (num.length() != 5) result = false;
	return result; 
}

Exercise 10:

Exercise 11:

1. true
2. false
3. false
4. true
5. true

Exercise 11:

Exercise 12:

1. False
2. True
3. True
4. False
5. True

End of Chapter Exercises

1. Write a function that converts Fahrenheit temperature degrees to Celsius using this formula: Celsius = (Fahrenheit – 32) * 5/9. The function should take a double parameter and returns a double. Add appropriate preconditions and postconditions comments. Hint, in C++ coding, the fraction 5/9 will result in 0 (why?!). To avoid this logical error, you should use 5.0/9.0 instead.
2.  In exercise 1, add a while loop to ask users if they wish to do another conversion.
3. In exercise 2, the while loop condition must be a bool function that returns true if the user wishes to repeat the calculation; otherwise, the function will return false to terminate the loop.
4. In Geometry, the distance between two points in the Cartesian Coordinate System is calculated by: \[ \text{distance =} \sqrt{{(x_2 \: – \: x_1)^2 + (y_2 \: – \: y_1)^2}} \] Write a function that asks users to enter the values x1, x2, y1, y2, and returns the distance between the two points. Round the result to the nearest integer. Add appropriate preconditions and postconditions comments.
5. Write a function that takes a string as input and returns an int that represents the number of vowels in the string.
6. Write a program that calculates the sum of all even numbers between 1 and 100. The program must use a Boolean function isEven that returns true if a number is even, otherwise, it returns false.
7. Write a bool function that checks whether a given year is a leap year or not. The function takes one int parameter representing the year value and returns true if the year is a leap year; otherwise, it returns false. You must include appropriate preconditions and postconditions comments describing the implemented algorithm. This is a good practice if you intend to share your code and want to be sure that other developers will understand how you solved the problem at hand. It would be helpful to conduct some research to gain a better understanding of the reasons behind the occurrence of leap years and their importance in calendar tracking.

The Algorithm:

Step 1: If the year is evenly divisible by 4, continue to step 2; otherwise, return false
Step 2: If the year is evenly divided by 100, continue to step 3; otherwise, return true
Step 3: If the year is evenly divisible by 400, return true; otherwise, return false

Thus, years such as 1996, 1992, and 1988 are leap years because they are divisible by 4 but not by 100. Years that are divisible by 4 and by 100 but not by 400 are not leap years. However, years that are divisible by 4, 100, and 400 are leap years, such as years 1600 and 2000.

8. Write a function that checks if a given sentence is a palindrome. A palindrome sentence is a sentence that reads the same forwards and backwards, considering only alphanumeric characters and ignoring spaces, punctuation, and capitalization. Do not forget the preconditions and postconditions comments to explain your algorithm.

Examples of Palindrome Sentences:
Madam, in Eden, I’m Adam.
Step on no pets.
Never odd or even.
Was it a car or a cat I saw?
No lemon, no melon.

9. Write a void function that takes a string parameter and prints its reverse.
10. Write a void function drawGraph(int rows) that prints a random number of * for every row it draws. A user must be allowed to choose how many rows they want to be drawn by passing an integer to the function argument. The total number of * printed on every row must not exceed 100. Below is a sample output:

Hint: You need to use nested loops to solve this problem.

Projects

Project 1: Write a program that simulates a simple calculator.

• The calculator should have the following functions: add, sub, div, mul, squareRoot, power, repeat, and menu.
• For the first four functions, users must be able to enter as many numbers as they want by calling a Boolean function called repeat that takes no parameters. The repeat function must recognize the responses, y, Y, yes, and Yes. If a user enters anything else, it will be considered as no.
• Use predefined functions to implement the squareRoot and power functions.
• For the div function, add code to prevent the error of dividing by zero.
• Menu is a void function that prints a list of options users can choose from to perform the desired calculation.
• All functions must have adequate preconditions and postconditions comments.

Project 2: The metric system and the American system (also known as the Imperial system) are two different systems of measurement used in different parts of the world.

• Write a program that converts values from one system to another.
• Each of the provided conversions must be implemented in a separate function.
• The program must have a Boolean repeat function that allows users to perform conversions as often as they want.
• The program must have a void menu function that prints menu options for users to choose from.
• All functions must have adequate preconditions and postconditions comments.

Length:

• 1 meter (m) = 3.281 feet (ft)
• 1 kilometer (km) = 0.6214 miles (mi)
• 1 centimeter (cm) = 0.3937 inches (in)
• 1 millimeter (mm) = 0.03937 inches (in)

Mass/Weight:

• 1 kilogram (kg) = 2.205 pounds (lb)
• 1 gram (g) = 0.03527 ounces (oz)

Volume:

• 1 liter (L) = 0.2642 gallons (gal)
• 1 liter (L) = 33.814 fluid ounces (fl oz)
• 1 cubic meter (m^3) = 35.3147 cubic feet (ft^3)

Temperature:

• To convert Celsius (°C) to Fahrenheit (°F): Multiply by 9/5 and add 32.
• To convert Fahrenheit (°F) to Celsius (°C): Subtract 32 and multiply by 5/9.

Project 3 Rock, Paper, Scissors: Read Project 2 from Chapter 3 again and redo it by allowing a player to play against the computer. That is, you have to add code that randomly selects one choice from the three available choices (rock, paper, scissors). Redesign the project by writing a couple of suitable functions rather than adding all the code in the main function as you did in Chapter 3.