Primitive Types

Variables and Constants

Naming conventions
Declaring Variables
Type conversions
Code example section

Basics Types and Variables

L07 - Types, Variables and Input

Department of Computer Science

University of Pretoria

05 March 2024
COS132 Basics Types and Variables
 Primitive Types
Variables and Constants
Naming conventions
Declaring Variables
Type conversions
Code example section

Overview
1 Primitive Types

2 Variables and Constants

3 Naming conventions

4 Declaring Variables

5 Type conversions

6 Code example section

COS132 Basics Types and Variables

 Primitive Types
Variables and Constants
Naming conventions
Declaring Variables
Type conversions
Code example section

A type provides the blue-print to which our

variables and constants that we create within
our program need to adhere. Types in C++
are categorised as Primitive (or built-in),
Derived and Abstract or (user-defined).

COS132 Basics Types and Variables

 Primitive Types
Variables and Constants
Naming conventions
Declaring Variables
Type conversions
Code example section

Primitive Types

Primitive types fall into two main categories.

Types where the previous and next values
of the type are predefined and types where
the previous and next values could
respectively be any value smaller or
greater than the current value.
COS132 Basics Types and Variables
 Primitive Types
Variables and Constants
Naming conventions
Declaring Variables
Type conversions
Code example section

Values that are predefined and therefore

predictable are said to be ordinal, while
values where we cannot determine the
next value in the sequence are values of
variable-length types.

COS132 Basics Types and Variables

 Primitive Types
Variables and Constants
Naming conventions
Declaring Variables
Type conversions
Code example section

1. Ordinal
Ordinal types are Integer, Character and
Boolean. The keywords used to represent
these types are int, char and bool
respectively.
2. Variable-length
Variable-length types include floating point,
of which there are two types: float and
double. The difference lies in precision.
COS132 Basics Types and Variables
 Primitive Types
Variables and Constants
Naming conventions
Declaring Variables
Type conversions
Code example section

Floating point data type stores

single-precision floating-point values, with
float typically requiring 4 bytes of memory
space.
Double floating point, on the other hand,
stores double-precision floating-point values
and typically requires 8 bytes of memory
space.
COS132 Basics Types and Variables
 Primitive Types
Variables and Constants
Naming conventions
Declaring Variables
Type conversions
Code example section

3. Type modifiers
In C++ type modifiers are used to change
the properties of basic data types, so that
programmers can define variables more
suited to the specific application. These
modifiers include: • signed (for int and char)
• unsigned (for int and char) • short (for int)
• long (for int and double)
COS132 Basics Types and Variables
 Primitive Types
Variables and Constants
Naming conventions
Declaring Variables
Type conversions
Code example section

1. Signed: Can store positive and negative

numbers. It does not change the storage
size, but halves the positive range to
accommodate negative values. The default
for C++ integers.
2. Unsigned: Can only store positive
numbers and zero, doubling the positive
range by eliminating the need for bits to
represent negative values.
COS132 Basics Types and Variables
 Primitive Types
Variables and Constants
Naming conventions
Declaring Variables
Type conversions
Code example section

3. Short: Reduces storage size and range of

values. Less memory usage, but also less
range.
4. Long: Increases storage size and range of
values. More memory usage, but also a
greater range.

COS132 Basics Types and Variables

 Primitive Types
Variables and Constants
Naming conventions
Declaring Variables
Type conversions
Code example section

COS132 Basics Types and Variables

 Primitive Types
Variables and Constants
Naming conventions
Declaring Variables
Type conversions
Code example section

1. Variables
A variable is a letter or word that can stand
in for any number, character, string, list,etc..
Think of a variable as a place-holder for a
value.
Variables in C++ are defned by providing a
type and name for the variable in the format:
(typename)(variablename)
COS132 Basics Types and Variables
 Primitive Types
Variables and Constants
Naming conventions
Declaring Variables
Type conversions
Code example section

(typename)(variablename)
where typename is one of the types given
in Table 3.1 and variablename the name
the variable will be referred to as in the
progoram.

Once a variable has been defined, a value

can be assigned to the variable.
COS132 Basics Types and Variables
 Primitive Types
Variables and Constants
Naming conventions
Declaring Variables
Type conversions
Code example section

An example of a definition of a variable is

given by:
int radius ;
( a variable with the name radius is defined
of type int).
This means radius may take on values that
are integers.

COS132 Basics Types and Variables

 Primitive Types
Variables and Constants
Naming conventions
Declaring Variables
Type conversions
Code example section

Rules for d e c l a r i n g variables :

1 . A v a r i a b l e name can c o n s i s t o f C a p i t a l l e t t e r s A−Z ,

lowercase l e t t e r s a−z d i g i t s 0 −9 , and t h e u n d e r s c o r e c h a r a c t e r .

2 . The f i r s t c h a r a c t e r must be a l e t t e r o r u n d e r s c o r e .

3 . B l a n k s p a c e s c a n n o t be u s e d i n v a r i a b l e names .

4. Special characters l i k e # and $ a r e n o t a l l o w e d .

5 . C++ k e y w o r d s c a n n o t be u s e d a s v a r i a b l e names .

6 . V a r i a b l e names a r e c a s e − s e n s i t i v e .

7 . V a r i a b l e t y p e can be b o o l , c h a r , i n t , f l o a t , d o u b l e , v o i d

COS132 Basics Types and Variables

 Primitive Types
Variables and Constants
Naming conventions
Declaring Variables
Type conversions
Code example section

2. Constant
Constants are used as a naming mechanism
for values that may not change during the
life of a program.
Typical values that can be defined as a
constant are Pl, MAX STUDENTS,etc
These values are defined once and can be
used a number of times within the program.
COS132 Basics Types and Variables
 Primitive Types
Variables and Constants
Naming conventions
Declaring Variables
Type conversions
Code example section

There are two ways that a constant:

1. Preprocessor method
A constant defined using the preprocessor
method is defined by using the keyword
define, providing a name for the constant
and a corresponding value.
As the constant is defined outside the main
function (and later you will see, outside any
other function),available to all parts.
COS132 Basics Types and Variables
 Primitive Types
Variables and Constants
Naming conventions
Declaring Variables
Type conversions
Code example section

The s y n t a x f o r d e f i n i n g a c o n s t a n t u s i n g t h e p r e p r o c e s s o r method
i s g i v e n by :
#d e f i n e <CONSTANTNAME> <c o n s t a n t v a l u e >

Below i s an e x a m p l e t o d e f i n e P I .
#d e f i n e P I 3 . 1 4 1 5

Program i l l u s t r a t e s w h e r e and how t h e c o n s t a n t i s d e f i n e d and u s e d

#i n c l u d e <i o s t r e a m >
#d e f i n e P I 3 . 1 4 1 5
u s i n g namespace s t d ;

i n t main ( )
{
c o u t << ”The a r e a o f a c i r c l e w i t h a r a d i u s o f 10cm i s : ”
<< P I ∗ 10 ∗ 10 ;
return 0 ;
}

COS132 Basics Types and Variables

 Primitive Types
Variables and Constants
Naming conventions
Declaring Variables
Type conversions
Code example section

2. const keyword method

Defining a constant using the keyword
method is similar to defining a variable in
C++.
To define a constant the keyword const must
be specified followed by the definition of
constant. A constant is identified by a name
and a type.
COS132 Basics Types and Variables
 Primitive Types
Variables and Constants
Naming conventions
Declaring Variables
Type conversions
Code example section

The s y n t a x t o d e f i n e t h e c o n s t a n t i s g i v e n by :
c o n s t <typename> <CONSTANT NAME> = < c o n s t a n t v a l u e >;

F o r example , t h e c o n s t a n t v a l u e 10 i s named RADIUS and i s o f t y p e

i n t i n t h e e x a m p l e b e l o w . R a t h e r t h a n u s i n g 10 i n t h e c o d e when
r e f e r r i n g t o t h e r a d i u s . c o n s t i n t RADIUS = 10 ;

D e p e n d i n g on w h e r e a c o n s t a n t i n d e f i n e d i n a C++ program ,
w i l l determine the scope of the constant .

#i n c l u d e <i o s t r e a m >
c o n s t f l o a t PI = 3 . 1 4 1 5 ;
u s i n g namespace s t d ;

i n t main ( )
{
c o n s t i n t RADIUS = 10 ;
c o u t << ”The a r e a o f a c i r c l e w i t h a r a d i u s o f 10cm i s : ”
<< P I ∗ RADIUS ∗ RADIUS ;
return 0 ;
}
COS132 Basics Types and Variables
 Primitive Types
Variables and Constants
Naming conventions
Declaring Variables
Type conversions
Code example section

3. Scope
Defining the constant outside the main
function enables the constant to be used
globally.
If the constant is defined within the
main function, only the main function
knows about the constant and can use
the constant.
COS132 Basics Types and Variables
 Primitive Types
Variables and Constants
Naming conventions
Declaring Variables
Type conversions
Code example section

4. Naming conventions
It is important that when you choose a name
for a variable or constant, it is descriptive.
This will make it easier to read the code.
Code that is easier to follow is easier to
maintain.
The variable name must begin with a letter
and may have no spaces.
COS132 Basics Types and Variables
 Primitive Types
Variables and Constants
Naming conventions
Declaring Variables
Type conversions
Code example section

You will see that throughout this text,

variables start with small letters and when a
variable consists of more than one word, the
other words start with capital letters.

This is merely a convention we follow for the

sake of readability e.g.
drawDoubleStoryHouse is more readable than
drawdoublestoryhouse.
COS132 Basics Types and Variables
 Primitive Types
Variables and Constants
Naming conventions
Declaring Variables
Type conversions
Code example section

Constant names are typically written in all

capital letters to easily distinguish them from
variables.
The variable type and the keyword constant
type is any valid type defined by the C++
language or the programmer.
Refer to Table 3.1. The preprocessor
constant type is determined by the compiler
based on the value given to the constant.
COS132 Basics Types and Variables
 Primitive Types
Variables and Constants
Naming conventions
Declaring Variables
Type conversions
Code example section

Variables can be initialized when declared:

int first=13, second=10;
char ch= ’R’;
string color = ”blue ” double x=12.6; All
variables must be initialized before they are
used But not necessarily during declaration

COS132 Basics Types and Variables

 Primitive Types
Variables and Constants
Naming conventions
Declaring Variables
Type conversions
Code example section

Int data type

Examples:
-6728
0
78
+763 Positive integers do not need a + sign,
No commas are used within an integer
Commas are used for separating items in a
list
COS132 Basics Types and Variables
 Primitive Types
Variables and Constants
Naming conventions
Declaring Variables
Type conversions
Code example section

Floating-Point Data Types

C++ uses scientific notation to represent
real numbers (floating-point notation)

COS132 Basics Types and Variables

 Primitive Types
Variables and Constants
Naming conventions
Declaring Variables
Type conversions
Code example section

1. float: represents any real number

Range: -3.4E+38 to 3.4E+38 (four bytes)
2. double: represents any real number
Range: -1.7E+308 to 1.7E+308 (eight
bytes)
On most newer compilers, data types double
and long double are same

COS132 Basics Types and Variables

 Primitive Types
Variables and Constants
Naming conventions
Declaring Variables
Type conversions
Code example section

Char d a t a t y p e :

The s m a l l e s t i n t e g r a l data type

Used f o r c h a r a c t e r s : l e t t e r s , d i g i t s , and s p e c i a l s y m b o l s

Each c h a r a c t e r i s enclosed in s i n g l e quotes

’A ’ , ’a ’ , ’0 ’ , ’ ∗ ’ , ’ + ’ , ’ $ ’ , ’& ’

A b l a n k s p a c e i s a c h a r a c t e r and i s written ’ ’,

with a space l e f t between the s i n g l e quotes

COS132 Basics Types and Variables

 Primitive Types
Variables and Constants
Naming conventions
Declaring Variables
Type conversions
Code example section

string Type
Sequence of zero or more characters
Enclosed in double quotation marks.
Example: string color = ”red”
Null: a string with no characters. Example:
string color = ” ”
Each character has relative position in string
-Position of first character is 0
COS132 Basics Types and Variables
 Primitive Types
Variables and Constants
Naming conventions
Declaring Variables
Type conversions
Code example section

bool Data Type

Two values: true and false
Manipulate logical (Boolean) expressions
true and false are called logical values
bool, true, and false are reserved words

COS132 Basics Types and Variables

 Primitive Types
Variables and Constants
Naming conventions
Declaring Variables
Type conversions
Code example section

In C++, type conversions, also known as

typecasting or coercion, refer to the process
of converting one data type into another.

Type conversions are essential for ensuring

compatibility between different data types in
expressions, assignments, and function calls.
C++ supports several mechanisms for type
conversions, namely:
COS132 Basics Types and Variables
 Primitive Types
Variables and Constants
Naming conventions
Declaring Variables
Type conversions
Code example section

1. Implicit Conversions
Implicit conversions are performed
automatically by the compiler when it
encounters expressions involving different
data types.
2. Explicit Conversions (Typecasting)
Also known as typecasts, are performed by
the programmer to explicitly convert a value
from one data type to another.
COS132 Basics Types and Variables
 Primitive Types
Variables and Constants
Naming conventions
Declaring Variables
Type conversions
Code example section

COS132 Basics Types and Variables

 Primitive Types
Variables and Constants
Naming conventions
Declaring Variables
Type conversions
Code example section

#i n c l u d e <i o s t r e a m >

i n t main ( ) {
// E x p l i c i t t y p e c a s t i n g
double x = 3.14;
i n t y = s t a t i c c a s t <i n t >(x ) ;

s t d : : c o u t << ” D o u b l e v a l u e : ” << x << s t d : : e n d l ;

s t d : : c o u t << ” I n t v a l u e a f t e r c a s t i n g : ” << y << s t d : : e n d l ;

// I m p l i c i t t y p e c a s t i n g
i n t a = 10;
d o u b l e b = a ; // I m p l i c i t c o n v e r s i o n from i n t t o d o u b l e

s t d : : c o u t << ” I n t v a l u e : ” << a << s t d : : e n d l ;

s t d : : c o u t << ” D o u b l e v a l u e a f t e r i m p l i c i t c a s t i n g : ” << b << s

return 0;
}

COS132 Basics Types and Variables

 Primitive Types
Variables and Constants
Naming conventions
Declaring Variables
Type conversions
Code example section

c i n i s u s e d w i t h >> t o g a t h e r i n p u t
c i n >>v a r i a b l e >>v a r i a b l e

The s t r e a m e x t r a c t i o n o p e r a t o r i s >>
F o r example , i f m i l e s i s a d o u b l e v a r i a b l e
c i n >> m i l e s ;
Causes computer to get a v a l u e o f type double
Places i t in the v a r i a b l e miles

COS132 Basics Types and Variables

 Primitive Types
Variables and Constants
Naming conventions
Declaring Variables
Type conversions
Code example section

Figure: EnterBasics
COS132 Caption
Types and Variables