Module 005 Handling Primitive Data Types

“Beyond a certain point, the whole universe becomes a continuous process of

initiation.”
–Robert Anton Wilson.

By this time, we are already in the formal part of our programming

adventure. Since all applications handle data, both computed and entered, we
need to know how to properly handle them and determine whether to store
them for future use or simply use them once and forget about them. Th is will
be the focus of this module, handling data types.

At the end of this module, you will be able to:

1. Differentiate variables from data types
2. Identify the classifications of variables
3. Identify the classifications of data types
4. Identify the different data types available in C++
5. Argue the practical data type to use

Again, researching beyond the coverage of this module is highly encouraged

to supplement your understanding of the topics covered. And as always,
think and see beyond the box.

So what are we waiting for? Let us continue our exploration of the world of
Computer Programming.

Course Module
Recall

In the previous module, we identified the essential components of our work

environment, namely:
a) Operating System
b) Integrated Development Environment
c) Compilers
d) Version Control
In addition, we learned how to configure our work environment through
step-by-step guide, namely:
a) Creating Github Account
b) Creating Github Repository
c) Downloading Visual Studio Code
d) Installing Visual Studio Code
e) Downloading Minimalist GNU for Windows
f) Installing MinGW Installation Manager
g) Installing MinGW Components
h) Configuring Microsoft Windows Path
i) Downloading Project Templates for Visual Studio
j) Adding C++ Extension to Visual Studio Code
Lastly, we worked on our very first C++ application, displaying “Hello
World!”.

Introduction

Handling data is similar as handling where we store and retrieve them. In

computers, the data is stored and retrieved in the RAM. Programming
languages make this possible through variables. Think of variables as a box
where we can store “valuables” in them. In this case, the “valuables” we store
within variables are values.

Handling Variables

We handle variables like we handle real-world boxes. When we take a box in

real-world that we plan to use as storage for our valuables, in Programming,
we declare the variable. When we place our valuables in the box, in
Programming, we assign a value to the variable. When this assignment is
done for the first time, we are initializing the variable. When we take our
valuables out of the box, in Programming, we are retrieving its value.
Course Module
There is a slight difference, however, then we take our valuables of the box
compared to when we retrieve the values of the variable. When we take our
valuables out of the box, we take them permanently. We do not have that
valuable anymore within the box after taking them out. In Programming,
however, when we retrieve the value of the variable, the value is still within the
variable. What we “take out” of the variable is just a copy of the value.

Variables

In programming languages, when talking about variables, we have the so -

called explicit, implicit and anonymous variables.

Explicit variables are variables that we declare, usually at the start of our
application before any processing is done within. They are made is such a
way that developers know they will be using a variable within the context of
the application. Most programming languages have explicit variables; they
require that variables are to be declared before they are used.

Implicit variables are variables that are used right away without the need of
declaring them. They are referenced using a name. They are made in such a
way that they are only allocated some memory when called. They are usable
within the context where they are initially used. Most programming
languages used in Web Development have implicit variables.

Anonymous variables are variables that are used right away without the need
of declaring them. They, however, are not referenced using a name. Only the
computer itself know how to call them. They are typically declared and
destroyed after use. Anonymous variables are used during computations

Major declarations are done as the first line of the “public void main()” function
for the explicit variables. Throughout the course, you will be using anonymous
variables without initially knowing you are using them.

In C++, we have explicit and anonymous variables.

Data Types

We use variables in par with data types. Data Types are the restriction we
place to variables that limit them to handle only our specified type of data.
Think of this like we are segregating our valuables to label boxes. Box 1,
labeled as “Tommy’s Box”, will only contain the valuables of Tommy. Box 2,
labeled as “Furniture”, will only contain the furniture, and nothing else like
food. Variables behaves in the same way like labeled boxes, they are limited
to their declared data type. We have two (2) classifications for data types:
a) By Value
b) By Construct

Classification by Value

When data types are classified by value, we have explicit and implicit data
types. ExplicitData Typesare the data types that are declared and defined. For
example, we declared a string variable, therefore we can only store string
values to that variable. We declared an integer variable, therefore we can
only store integer values to that variable.

Explicit Data Types are often called “Strong-typed” in some other contexts. This
is mainly because of how the values to be stored are treated. In addition, being
called “Strong-typed” suggests that there exists a bound between the data
types, by extension including the variables, and the value stored.

Implicit Data Types are data types that are taken depending on how they are
stored or used. They are not defined which often causes ambiguity on how
the values are to be handles.

Implicit Data Types are often called “Variant” type. They are especially used in
Web Development wherein the values, like those which come from the users,
are initially treated like strings before they are converted to what they are
actually.

In C++, we only have Explicit Data types.

Course Module
 Classification by Construct

Data Types can also be classified by construct. By construct in Programming

means by how they are constructed. It also means by what they are
composed of.

Primitive Data Types are data types of singularity by nature. They contain
only the values they are supposed to contain. They do not have any other
components like properties and internal functions. They are like folders for
paper. They are used only to contain papers and nothing else like writing
pens, chips and cars.

C Programming Language only have Primitive Data Types. They have

“structures” but not full-bodied “classes” which are the fundamental
implementation of Referenced Data types.

Referenced Data Types are data types that are objective by nature. They do
not only contain the values they are supposed to contain, but also have other
components like properties and functions. They contain variables within
them. They are like car garage. They can contain anything within them, not
only the cars which they are made for. They can contain fuel containers,
workbenches and spare tires. In addition, they also serve different
functionalities like they enable automatic closing of garage doors, internal
lightings, and vents.

In C++, we have both Primitive and Referenced Data Types.

Primitive Data Types

Primitive Data Types in C++ are classifiable in integers, floating points and
characters. This classification is based on what specific values are allowable.
Integers, floating points and booleans are numerical values, whereas
characters are textual values.

Integers
 Integers are values that are numerical in nature. They do not have decimal
precisions. Some examples of these are counting numbers including zero
(0).Under Integers, we have the regularinteger, long and short data types.
Table 1 and 2 show the minimum and the maximum values allowable for the
Integer Values, both signed and unsigned integer values.

Data Type Identifier Minimum Value Maximum

Regular [signed] -2,147,483,648 2,147,483,647

Integer int

Short [signed] -32,768 32,767

Integer short

Long Integer [signed] -9,223,372,036,854,775,808 9,223,372,036,854,775,807

long
Table 1. Signed Integers Value Boundaries

In addition to these data types, we have a singed and unsigned identifiers for
integer data types. When we do not specify any of the two identifiers, C++
implicitly interprets them as if you have placed a singed identifier.

Data Type Identifier Minimum Value Maximum

Regular Integer unsigned int 0 4,294,967,295

Short Integer unsigned short 0 65,535

Long Integer unsigned long 0 18,446,744,073,709,551,615

Table 2. Unsigned Integers Value Boundaries

Exceeding the set boundaries for the Integer Values results to what we call
“overflow”. Causing overflows results to unexpected outcomes which typically
results for the application to terminate.

Floating-points

Floating Points are values that are numerical in nature. They also sport
decimal precisions. Some examples are temperature, body-mass index and
height. Table 3 shows the minimum and maximum values allowable for
floating-point values.

Course Module
 Data Type Identifier Minimum Value Maximum

Float float 1.175494351e–38F 3.402823466e+38F

Double double 1.7976931348623158e+308 2.2250738585072014e-308

Table 3. Floating-point Value Boundaries

Booleans

Boolean Values are values classifiable to either a true or false. These are
numerical in nature because C++ stores them as zero (0) or zero (1),
internally. True value for booleans are considered as non-zero positive
integer. False value for booleans are considered as zero. They are usually
used as flags for a specific scenario. They use bool identifier.

Characters

Characters are the only primitive data type that is textual in nature. Regular
characters can only represent one (1) character per variable. Strings can be
represented as a series of characters. That is why, in programming languages
such as C++, a string is declared as an array of characters. Characters use
char identifier, whereas Strings use char variable[ ]syntax.

To declare Strings in C++, we indicate the maximum number of characters to

be used in the string. For example, if we will need to allocate 50 empty
characters to contain a String, we will declare it using “char x[50]”. If we need
555 empty characters, we declare “char x[555]”.

Data Types in Action

Now that we have covered all the supported Primitive Data Types in C++, we
need to discern the importance of having different data types and when we
will generally use them in real-world applications.

Data Structures
 First thing we need to know is how the computer in general, the Operating
System and the CPU in particular handle variables. When we declare a
variable, the computer allocates a specific empty and unused region in the
RAM where to store the supposed value. How big the allocation will be
depends on the maximum value of the data type. This is the main reason why
we have varying lengths for our integer and floating points.

Now, remember that the computer essentially only understands binary, a

series of 0’s and 1’s. If we take unsigned short integers as our example, the
maximum value allowable for them is 65,535. In binary that is sixteen (16)
1’s – 1111 1111 1111 1111. Hence the computer will allocate sixteen sectors
if we declare one unsigned short integers.

The same thing applies for [signed] short integers. However, the least
significant bit (the left-most bit), symbolizes the parity of the sign. For the
value 32,767, we will have 0111 1111 1111 1111 in binary. For the value -
32,768, we will have 0111 1111 1111 1111 in binary.

A Character data type occupy 8-bits. The value differs on how the compiler
sets the value of the characters. For example, Compiler A can store the
character “A” as 0000 0000, while Compiler B can store the character “A” as
0100 0000.

Booleans occupy only 1-bit, either 0 or 1. For true, it is 1. For false, it is 0.

When integers are used in Boolean expressions, a 0-valued integer is
interpreted as false and a positive-valued integer is interpreted as true.
Negative-valued integers are not represented in Booleans, as such they
typically result in application crashes or errors during compilation.

The course about “Data Structures” will discuss in detail about binaries,
parities and the like which are relevant on how data are stored within
computers. This includes the complex operations the computer perform on
floating-points.

Real-world Application

Now that we understand how Data Types work technically and theoretically,
we need to discern what the most applicable data types per scenar io is. Since
there are an unlimited number of possible scenarios, we will only tackle the
most common and general of them.
Course Module
First is when we handle any numeric values, we know to choose only
between integers and floating-points. What determines which of the two will
be used relies on the need to store the decimal values. When we count the
number of occurrences of a specific object, we can use integer values. They
mainly differ on how large the value could go. For example we need to count
the number of cars in the garage, we can use short. If we take the overall
populations in the world, we need to use long.

One of the Internet giants, Google, recently changed the data type of their
“Thumbs Up” variable from “int” to due to a short commotion that occurred in
the official Psy’s Gangnam Style video in YouTube. This is because the limit of
int was reached forcing YouTube to change the data type to Int64 – essentially
the long data type in C++.

For values needing decimal precision, we use floating points. If we are simply
storing the temperature of a given specimen, we can use float. However, if we
take monetary values, we need to use doubles. This is mainly because
monetary values typically reach millions and billions.

If we only need to check the parity of an object or state, we only need to use
the Boolean. If we need to know whether the user is, biologically speaking, a
male. We can use “bool isMale;” rather than any other data types like the
storage heavy string. This is because if the “isMale” results to a false, we
automatically know the user is a female. There is no gender in between of the
two biologically speaking.

In these scenarios, we mainly base our decision in the maximum number we

anticipate the values could become. We should never take the data types for
granted because the computing and storing capabilities of computer are
limited. Incorrect usage of these resources can cause not only the application
to fail, but also the entire operating system.
Glossary
Variable: A temporary storage of value.
Explicit [Variables]: Variables that are declared and are assigned a name.
Implicit [Variables]: Variables that are not declared but are assigned a
name.
Anonymous [Variables]: Variables that are not declared and are not
assigned a name.
Data Type: A means to limit the types of values to be stored in a variable.
Strong-typed [Data Type]: see Explicit Variables.
Variant [Data Types]: Data types that can store any type of values.
Primitive [Data Types]: Data types that directly store the values within
them and are retrieved within their own parameters.
Referenced [Data Types]: Data types that references to different sectors in
the memory to store and retrieve values. Values stored in Referenced Data
Types are not stored and retrieved within the variable, but are stored and
retrieved to another address the computer implicitly assigned it.
Decimal Precision: Allows values to contain decimal point and numbers at
the right of the decimal point.
Integer Values [Data Types]: Data types that are numerical in nature and
does not have decimal precision.
Floating Point [Data Types]: Data types that are numerical in nature and do
have decimal precision.
Booleans [Data Types]: Data types that are either true or false, but not both,
in value.
Characters [Data Types]: Data types that are textual in nature. They
represent only one character of the text.

Course Module
References and Supplementary Materials
Books and Journals
Nell Dale; 2013; C++ Plus Data Structures, Fifth Edition; Massachusetts; Jones
& Bartlett Learning, LLC
Mike Dawson; 2015; Beginning C++ Through Game Programming, 4 th Edition;
Boston; Cengage Learning

Online Supplementary Reading Materials

C++ data types;
http://www.austincc.edu/akochis/cosc1320/dataTypes.htm; June 18,
2017
Fundamental types; http://en.cppreference.com/w/cpp/language/types;
June 18, 2017
Floating Limits; https://msdn.microsoft.com/en-us/library/6bs3y5ya.aspx;
June 18, 2017
Gangnam Style Overflows INT_MAX, forces YouTube to go 64-bit;
https://arstechnica.com/business/2014/12/gangnam-style-
overflows-int_max-forces-youtube-to-go-64-bit/; June 18, 2017
Integer Limits; https://msdn.microsoft.com/en-us/library/296az74e.aspx;
June 18, 2017
No, 'Gangnam Style' Didn't Break YouTube. We Did the Math;
https://www.wired.com/2014/12/gangnam-style-youtube-math/;
June 18, 2017