Variables and Data Types in C++

Dr Ian Cornelius

Hello

Hello (1)

Learning Outcomes

Understand what a variable is, and the various data types in C++
Demonstrate the ability to declare variables of various data types

Variables

Variables (1)

You should remember what a variable is from the first year programming module
To recap:
- a variable is a reserved memory location to store values of a particular data type
- consist of two parts: a name and a value
There are a few rules to follow when naming your variables:
1. Names must start with a letter or an underscore
2. Names can only contain alphanumeric characters and underscores (A-z, 0-9, and _)
If you need to supply a comment to explain a name, then it does not reveal its true intent
- if this is the case, then you may want to reconsider renaming your variable
Note: that variable names are case-sensitive:
- i.e. module, Module and MODULE are all different variables (and memory locations)

Before we begin looking at the process of declaring a variable in C++, I want to recover some of the conventions we discussed in the first year programming module. Hopefully, you should be able to recall that a variable is a reserved memory location on a local machine that will store a particular data type. They consist of two parts, a name operand and a value operand. The names of these variables can be long or short, but within reason.

There are some rules that can be followed when it comes to naming your variables, these are:

Variable names must always start with a letter, or an underscore. You will almost certainly never be able to start a variable name with a number, but a number may be used elsewhere in the naming position.
Names may only contain alphanumeric characters, so that would be the entire alphabet (either upper-case or lower-case), digits between zero and nine, and you may also include an underscore.
Names are also case-sensitive, therefore, a variable called upper-case X is different to a variable called lower-case x.

This then leads us nicely onto three questions that you should ask yourself when it comes to naming a variable:

Why does it exist?
What does it do?
How is it used?

Asking yourself these questions will ensure that you name a variable correctly and eradicate any confusion from another developer who may be reading your code. For example, if you need to supply a comment next to the variable declaration to explain what it is, then you are doing this wrong and may want to reconsider an alternative name.

Variables (2)

Declaring a Variable

Variable declaration in C++ is different compared to Python
C++ requires you to declare the data type at the beginning of declaration
- note: the semicolon (;) - this is important!
Variables are assigned values using the equal symbol (=)
- the operand to the left of the = is the name of the variable
- the operand to the right of the = is the value of the variable

Python Declaration

aVariable = "String Data Type"
anotherVariable = 1.0

C++ Declaration

string aVariable = "String Data Type";
float anotherVariable = 1.0;

When it comes to declaring variables using the C++ language, it is different compared to Python. With Python, it is rather straight forward with creating a variable, you type the name, followed by an equals character, and you then populate it with a value. On the screen, you can see that I am creating two variables in Python with a string and float data type.

However, with C++, you must declare the type of data that is being stored in the variable before creating the variable name. On the right-hand-side of the screen, you will see the C++ declaration for the same two variables from the Python example. You can see with the C++ implementation, before we provide a name for the variable we must declare the type of data that will be stored, in this instance we have provided string and float, respectively. This is then followed by the name of the variable, the equals character, and the value that we wish to store in that variable.

It is important to note that at the end of our variable declaration there is a semicolon. This is crucial in the C++ programming language. The semicolon denotes the end of a statement, and terminates our variable declaration. You will see these popping up alot in the C++ lectures.

Data Types

Data Types (1)

Data types represent the data that is stored in the memory of the computer
There are two types of data types:
- basic: these are native to C++, they consist of:
  - Boolean
  - Character
  - String
  - Numeric
  - Vectors/Arrays (Discussed in Week 8)
  - Maps (Discussed in Week 8)
- user-defined: these are created by the programmer in the forms of classes and objects
  - classes and objects are discussed in Week 9

You should be familiar with the concept of declaring a variable in C++, it is relatively straight-forward, apart from a few modifications compared to the Python programming language. Over the next few slides, we shall be looking at the various data types that can be represented in C++. The programming language contains two types of data types:

basic
and, user-defined

The basic data types are those that are native to C++ and consist of the following: boolean, character, string, numeric, vectors/arrays and maps. The latter two native data types will be discussed in week eight. The other type is user-defined, and we introduced this concept in your first year programming module. User-define data types are those that have been created by the programming in the form of objects which have been derived from a class. Classes and objects will be discussed in week nine.

Data Types (2)

Boolean

Declared using the bool keyword
Represents boolean values which are either true or false
- note: these are case-sensitive and are all lower-case compared to Python
When returned, the value of a boolean is numeric
- true = 1
- false = 0

#include <iostream>
bool boolExample1 = true;
bool boolExample2 = false;
int main() {
    std::cout << "boolExample1 -> " << boolExample1 << std::endl;
    std::cout << "boolExample2 -> " << boolExample2 << std::endl;
    return 0;
}

boolExample1 -> 1
boolExample2 -> 0

The first data type we shall begin with is the boolean type. You should recall from earlier that when it comes to declaring a variable in C++, we need to be strict with our declaration and provide the type of data we are initialising at the beginning of the variable name. In this case, for a boolean, we need to use the bool keyword.

Just like Python, a boolean is a true or false value and are represented in all lower-cases. However, things are a little different when it comes to returning a boolean variable. Instead of true or false being returned, as was the case in Python. In C++, the values that are returned are their numeric form, in this instance 1 or 0; where 1 represents true and 0 represents false.

On the right-hand-side of the screen, you will see an example of how we can declare a variable with a boolean data type. You will see that I have used the keyword bool at the beginning of our variable name, followed by an equals character and then the true or false value. However, when we print the value of our variables, you can see that true or false have not been returned, although we initially set our variables with these values.

Instead, what has been returned are 1 and 0, which are the numeric representations of true and false, respectively. This is because the C programming language, which C++ is based upon, does not have a boolean data type and as such the integer values are used as their representation instead.

Data Types (3)

Character

Declared using the char keyword
Stores a single character
- must be surrounded by a set of single quotes (')

#include <iostream>
char charExample1 = 'A';
char charExample2 = 'b';
char charExample3 = 'abc';
int main() {
    std::cout << "charExample1 -> " << charExample1 << std::endl;
    std::cout << "charExample2 -> " << charExample2 << std::endl;
    std::cout << "charExample3 -> " << charExample3 << std::endl;
    return 0;
}

charExample1 -> A
charExample2 -> b
charExample3 -> c

The next data type we shall be looking at is the character type. You may not have come across this data type beforehand, and that is because it does not exist in Python. To create a character variable, the char keyword is used and should prefix the name of the variable being used to store this data type.

This data type will only store a single character, with an emphasis on the word single. Therefore, do not expect it to store multiple values. It is also important to highlight that when you declare a character it uses a set of single quote characters. This indicates the C++ compiler that a character has been stored and not a string, more on this in a second.

On the right-hand-side of the screen, you will see an example, where two characters are being stored in separate variables. The first example, you can see that a variable charExample1 has been created, with the keyword char prefixing it. The variable has been created to store the value upper-case a and is represented inside a set of single quotes to denote that it is a character. The same process has been repeated for the second variable called charExample2, which is storing a lower-case b character.

When the code is executed, you can see that the characters are returned and printed to the terminal window. However, if you attempt to include more than one character for a variable, then a warning will be raised. In this instance, an overflow warning will be presented and only the last character declared will be returned, as can be seen in the third example.

Data Types (4)

String

Declared using the string keyword
Stores multiple characters, otherwise referred to as a sequence of characters
- must be surrounded by a set of double quotes (")
Not strictly an in-built data type
- requires an additional module to include called string

#include <iostream>
#include <string>
std::string strExample1 = "This is with numbers: 1, 2, 3, 4.";
std::string strExample2 = "A";
int main() {
    std::cout << "strExample1 -> " << strExample1 << std::endl;
    std::cout << "strExample2 -> " << strExample2 << std::endl;
    return 0;
}

strExample1 -> This is with numbers: 1, 2, 3, 4.
strExample2 -> A

I briefly touched upon strings in the previous slide, and that is because they are declared in a different manner compared to characters and Python. You may recall in Python that a string can be declared using either a single or double quote. However, it is completely different in Python and you can only use the double quote character. That is because, as you have just seen, the single quote character is reserved for declaring character data types.

When it comes to declaring a string data type, the variable name must be prefixed with the keyword string. You should recall forming your first year programming module that strings store multiple characters. However, it is not strictly a native data type for C++ and requires using an additional module named string.

On the right-hand-side of the screen, you will see an example of how we will go about creating a string using the C++ programming language. The slight difference in this case, is that because we are using another module to create our strings, then the std namespace has been prefixed to the string keyword. As you can see from the first example, a string can hold pretty much any character found on the keyboard, whether it be an alphanumeric character, or a character such as a colon.

Numeric Data Types

Numeric Data Types (1)

There are three numeric data types in C++:
- Integers
- Floats
- Doubles

Numeric Data Types (2)

Integer

Declared using the int keyword
Represents an integer number, i.e., a number without a decimal point
The integer data type represents both huge negative and positive integer numbers
- a range from -2147483648 to 2147483648

#include <iostream>
int intExample1 = 1;
int intExample2 = -1024;
int main() {
    std::cout << "intExample1 -> " << intExample1 << std::endl;
    std::cout << "intExample2 -> " << intExample2 << std::endl;
    return 0;
}

intExample1 -> 1
intExample2 -> -1024

The first numeric data type we shall be looking at is the integer type. You will recall from your first year programming module that an integer is considered to be a whole number, that is a number without a decimal point. Integers in C++ are able to store a number in four bytes, meaning we can get really long numbers as those shown on the third bullet point.

As usual, when it comes to creating an integer variable, we need to prefix the variable name with a keyword. In this instance, for integer, the int keyword is used, followed by a name in which we want to refer to this variable as. For this example, I have used the name intExample1 in a camel-case fashion. The first example stores a positive value of 1, whilst the second example stores a negative value of -1024.

Numeric Data Types (3)

Float

Declared using the float keyword
Represents a floating point number, i.e., a number with a decimal point

#include <iostream>
#include <iomanip>
float floatExample1 = 1.584;
float floatExample2 = 1024.9876453;
int main() {
    std::cout << "floatExample1 -> " << floatExample1 << std::endl;
    std::cout << "floatExmaple2 -> " << floatExample2 << std::endl;
    std::cout << "floatExmaple2 -> " << std::setprecision(20) << floatExample2 << std::endl;
    return 0;
}

floatExample1 -> 1.584
floatExmaple2 -> 1024.99
floatExmaple2 -> 1024.9876708984375

The second numeric data type we shall be looking at is the float data type. You may remember that a floating number is a number that contains a decimal point, and just like integers, they can store a large range of numbers. In C++, a float can store a number up to seven decimal digits in precision, and stored in four bytes.

In order to create a floating point variable, the float keyword is used, as can be seen in the examples on the right-hand-side of the screen. The first example is concerned with creating a variable holding the value 1.584, whilst the second example creates a variable storing the value 1024.9876453. You can see that when these two variables are printed to the screen, the first example returns the value we have specified, 1.584. However, when it comes to our second value, you can see that some rounding has occurred. In this case, instead of expecting to see 1024.9876453 we get the value, 1024.99 returned to us. But why is this?

Well the cout function has been designed to round floating point numbers to two decimal places. Therefore, in order for us to get around this, we need to set the precision to get the desired precise value of our numbers. To do this, we can use the setprecision function from the iomanip module. This function will accept a parameter, n, which can specify the number of digits to be printed after the decimal point.

As you can see from the third example, when we apply the setprecision function to our floating point number, all the values after the decimal point have been returned to the screen. You only need the setprecision function once in your script in order for it to carry throughout. However, if you need to change the precision value, for example, from twenty to thirty, then you need to call the function once again.

Numeric Data Types (4)

Double

Declared using the double keyword
Represents a floating point number, i.e., a number with a decimal point

#include <iostream>
#include <iomanip>
double dblExample1 = 1.584;
double dblExample2 = 1024.9876453;
int main() {
    std::cout << "dblExample1 -> " << dblExample1 << std::endl;
    std::cout << "dblExample2 -> " << dblExample2 << std::endl;
    std::cout << "dblExmaple2 -> " << std::setprecision(20) << dblExample2 << std::endl;
    return 0;
}

dblExample1 -> 1.584
dblExample2 -> 1024.99
dblExmaple2 -> 1024.9876452999999401

This leads us nicely onto the third numeric data type, double. You may be thinking to yourself that you have not come across this data type before, and that is because you have not. We do not use this data type in Python, but in older languages such as C++ and Java, then the double data type exists. It is similar to a float, but it can store a number with a larger number of decimal points. In general, a double can store a number with fifteen decimal digits.

To create a double in C++, you will need to use the double keyword, and prefix this to the beginning of the variable name. From the examples on the right-hand-side of the screen, you can see that two variables have been created, dblExample1 and dblExample2 each storing the values 1.584 and 1024.9876453, respectively.

You can see that when we print the first variable to the screen, the value 1.584 is returned. However, it is in the second example where things become a little more interesting. For example, the first instance of printing the variable dblExample2 returns 1024.99, which is not the value we originally stored. This is because, as explained earlier, the cout function is rounding the value up to two decimal points.

However, when we set the precision to twenty, and we print the variable for the third time, we get a different number once again. This time, the number that is returned is 1024.9876452999999401. Once again, you are probably asking why is this? Well, the simple answer is because the precision of a double is higher compared to that of a float.

You will remember that on the previous slide, the precision of a float was seven decimal digits. Well, with a double, our precision point has doubled to fifteen decimal digits. Therefore, when we print the value of dblExample2 for the second time, and with a precision of twenty, the compiler will make use of those fifteen decimal points.

Numeric Data Types (5)

Floats vs. Doubles

The difference between the two is the floating point value
- indicates the number of values after the decimal point
Float can have seven digits
- i.e. 10.1234567
Double can have fifteen digits
- i.e. 10.1234567890123456

Example: Float Division

#include <iostream>
#include <iomanip>
float floatExample1 = 1.0 / 81;
float floatExample2 = 0.0;
int main() {
    for (int i = 0; i < 729; ++i) {
      floatExample2 += floatExample1;
    } 
    std::cout << "floatExample2 -> " << std::setprecision(7) << floatExample2 << std::endl;
    std::cout << "floatExample2 -> " << std::setprecision(15) << floatExample2 << std::endl;
    return 0;
}

floatExample2 -> 9.000023
floatExample2 -> 9.00002288818359

Example: Double Division

#include <iostream>
#include <iomanip>
double dblExample1 = 1.0 / 81;
double dblExample2 = 0;
int main() {
    for (int i = 0; i < 729; ++i) {
      dblExample2 += dblExample1; 
    }
    std::cout << "dblExample2 -> " << std::setprecision(7) << dblExample2 << std::endl;
    std::cout << "dblExample2 -> " << std::setprecision(15) << dblExample2 << std::endl;
    return 0;
}

dblExample2 -> 9
dblExample2 -> 8.99999999999996

Let’s have a look at this in a little more detail. On the screen we have the same division being made, with the only difference being the data type declaration, one being a float and the other being a double. However, as you can see, the outcome of each division is different.

Let’s start by looking at the float division on the left-hand-side of the screen. Here, we can see that when the precision is set to seven and fifteen, respectively, we get two different values returned to us. The first value is 9.000023 whereas the second value is 9.00002288818359. Obviously, we can see that the second value has been rounded-up due to the number of decimal points being limited in the first.

However, when we use a double for our arithmetic operation, the outcome is different. For example, the first value returned for dblExample2 is 9. But when we change the precision to fifteen decimal places, it can be seen that the value is in fact 8.99999999999996, which is considerably different to what the floating-point example was returning us. But why is this? Well, it’s because a double has twice the precision than that of a float, and as such is going to be more accurate in the calculations it is performing.

Which leads me on to say… that when it comes to using decimal numbers in C++, you more than likely will want to use a double to store your value, as it will be more accurate than a floating point number.

Goodbye

Goodbye (1)

Questions and Support

Questions? Post them on the Community Page on Aula
Additional Support? Visit the Module Support Page
Contact Details:
- Dr Ian Cornelius, ab6459@coventry.ac.uk