DATA TYPES - C++

DR.M.KARTHIKA, M.C.S. A.,M.PHIL.,PH.D.,

Assistant Professor/MCA Department,
N M S S V N College
Madurai-19.

Over view

Basic Program Structure

Bits/Memory

Data Types

Type Conversion

Operators

Control Structures

Arrays
2

Computers are Easy!

"Using a computer is just like riding a bike, except

you don't have to wear the tight shorts and funny
helmet. A water bottle is also a bad idea. Just
about everyone agrees that computing is very
simple, or will be in only a few more days.

David Lubar, 1995

Basic Program Structure

// Program description
#include directives
int main()
{
constant declarations
variable declarations
executable statements
return 0;
}
4

Do you see a couple or a skull?

A Data Type

A data type is
A set of values AND
A set of operations on those values

A data type is used to

Identify the type of a variable when the variable is
declared
Identify the type of the return value of a function
Identify the type of a parameter expected by a
function

Design issues of data types

How is the domain of the values

specified?
What operations are defined and how
are they specified?
What is the syntax of reference to the
variables?

10

Data Inside the Computer

All data types are transformed into a
uniform representation
They are stored in a computer and
transformed back to their original form
when retrieved.
This universal representation is called a bit.

11

BIT
Binary Digit
pattern or a sequence of 0s and
1s.

12

Storage of Different Data Types

13

Objective of Data Type

Is to process data
Data is classified into specific types
Numerical
Alphabetical
Audio
Video

C++ allows only certain operations to be

performed on certain types of data
Prevents inappropriate programming operations
14

Data Type:
A set of values together with a set of operations is
called a data type.
C++ data types fall into three categories
Simple Data Type.
Structured Data Type.
Address(Pointers).

15

Set of values and operations that can be applied

to these values

Example of a data type: Integer

The values: set of all Integer (whole) numbers
The operations: familiar mathematical and
comparison operators

16

Major Classification
User Defined data type
Programmer-created data type
Set of acceptable values and operations defined by a
programmer using C++ code

Built-in data type

Provided as an integral part of C++
Also known as a primitive type
Requires no external code
Consists of basic numerical types
Majority of operations are symbols (e.g. +,-,*,)
17

Basic Data Types

C++ Data Types

User-defined Type

Built-in Type

Derived Type

structure
union
class
enumeration

array
function
pointer
reference

Integral Type

int

Void

char

Floating Type

float

double

18

C++ Data Types

simple

integral
char short

structured

enum floating

array struct
class

union

int long bool

float double

address

long double

pointer

reference
19

C++ Primitive Data Types

Primitive types

integral

char

short

floating

int

long

bool

float

unsigned
20

Size Unique

representable values

8-bit

256

16-bit

65 536

32-bit

4 294 967 296

= 28
= 216
= 232 (~4 billion)

64-bit 18 446 744 073 709

billion billion)

551 616

= 264 (~18

21

Data types in C++

Data Type

Memory (ByteS)

Minimum Value

Maximum Value

Bool

Logical Value T/F

Logical Value T/F

Char

-128

127

Unsigned Char

255

Short

-32768

32767

Unsigned Short

65535

int

-32768

32767

unsigned int

65535

Long

-2147483648

2147483647

unsigned long

4294967295

float
double

4
8

10-38
10-308

1038
10308

long double

10

10-4932

104932

22

Simple Data Type

C++ simple data can be classified into three

categories
1. Integral, which is a data type that deals
with integers, or numbers without a
decimal part.
2. Floating-point, which is a data type that
deals with decimal numbers.
3. Enumeration type, which is a user-defined
data type.
23

24

Integer
An integer type is a number without a
fractional part. It is also known as an
integral number. C++ supports three different
sizes of the integer data type: short int, int
and long int.
sizeof(short int)<= sizeof(int)<= sizeof(long int)

Short int
int
long int
25

STORING OF DATA TYPES

A number is changed to the binary

system before being stored in the
computer memory
However, there are still two issues that
need to be handled:
1. How to store the sign of the number.
2. How to show the decimal point.

26

Storing Integers
Integers are whole numbers (numbers without a
fractional part).
For example, 134 and 125 are integers,

whereas134.23 and 0.235 are not.

An integer can be thought of as a number in
which the
position of the decimal point is fixed:
the decimal point is to the right of the least
significant (rightmost) bit.
For this reason,
fixed-point representation is used to store
an integer,
as shown below.
27

An integer is normally stored in memory using fixed-point represen

28

Unsigned Representation

An unsigned integer is an integer that can never be

negative and can take only 0 or positive values. Its
range is between 0 and positive infinity.

An input device stores an unsigned integer using the

following steps:

1. The integer is changed to binary.

2. If the number of bits is less than n, 0s are added to
the left.

29

Example
Store 7 in an 8-bit memory location using
unsigned representation.
Solution
First change the integer to binary, (111)2.
Add five 0s to make a total of eight bits,
(00000111)2.
The integer is stored in the memory location.

Note that the subscript 2 is used to emphasize that

the integer is binary, but the subscript is not stored in the
computer.

30

Example:
Store 258 in a 16-bit memory location.
Solution
First change the integer to binary (100000010)2.
Add seven 0s to make a total of sixteen bits, (0000000100000010)2.
The integer is stored in the memory location.

31

Sign-and-Magnitude
Representation
In this method, the available range for unsigned integers (0 to 2n1)
is divided into two equal sub-ranges.

The first half represents positive integers, the second half, negative
integers.
Noted that there are two different representations for zero.

In sign-and-magnitude representation, the leftmost bit defines the

sign of the integer. If it is 0, the integer is positive. If it is 1, the
integer is negative.

32

Store +28 in an 8-bit memory location

using sign-and-magnitude
representation.
Solution
The integer is changed to 7-bit binary.
The leftmost bit is set to 0. The 8-bit
number is stored.

33

Store 28 in an 8-bit memory location

using sign-and-magnitude
representation.
Solution
The integer is changed to 7-bit binary.
The leftmost bit is set to 1. The 8-bit
number is stored.

34

The bool Data Type

The data type bool has two values, true and
false.
The central purpose of this data type is to
manipulate logical (Boolean) expressions.
We call true and false the logical (Boolean)
values.
In C++, bool, true, and false are reserved
words.
35

Char Data Type

char is the
smallest integral data type.
char data type is used to represent characters, that is
letters, digits and special symbols.
Each character is enclosed within single quote marks.
Some of the values belonging to char data type are:
'A', 'a', '0', '*', '+', '$', '&
Blank space is a character and is written ' ', with a
space left between the single quotes.
36

The Most Common Character Sets:

ASCII (American Standard Code for Information
Interchange) and EBCIDIC. (Extended Binary-Coded
Decimal Interchange Code (IBM))

The ASCII character set has 128 values.

EBCIDIC has 256 values and is used by IBM.

37

ASCII Character Set

Each of the 128 values of the ASCII character set represents a

different character.
The value 65 represents 'A', and the value 43 represents '+'.
Each character has a pre-defined ordering, which is called a collating
sequence, in the set.
The collating sequence is used when you compare characters.
The value representing 'B' is 66, so 'A' is smaller than 'B'.
'+' is smaller than 'A' since 43 is smaller than 65.
The first 32 characters in the ASCII character set are nonprintable.
The 14th character in the set is the new line character.
In C++, the new line character is represented as '\n'.
The horizontal tab character is represented in C++ as '\t'.
The null character is represented as '\0'.
38

ASCII (American Standard Code for Information Interchange)

0 nul

soh

stx

etx

1 lf

vt

ff

cr

2 dc4

nak

syn

etb

3 rs

us

4(

52

6<

enq ack

bel

bs

ht

so si del

dc1

dc2

dc3

em sub

esc

fs

gs

eot

can

&

>

7F

8P

9Z

10

11

12

del

39

Floating Point
A floating-point type is a number with a
fractional part, such as 43.32. The C++
language supports three different sizes of
floating-point: float, double and long double.
sizeof(float)<= sizeof(double)<= sizeof(long double)

float
double
long double
40

Floating-Point Data Types

Scientific notation
43872918 = 4.3872918 *10^7

{10 to the power of seven},

.0000265 = 2.65 * 10^(-5) {10 to the power of minus five},

47.9832 = 4.7983 * 10^1

{10 to the power of one}

To represent real numbers C++ uses scientific notation called

floating-point notation.

41

float: The data type float is used in C++ to represent

any real number between -3.4E+38 and 3.4E+38.The
memory allocated for the float data type is 4 bytes.
double: The data type double is used in C++ to
represent any real number between -1.7E+308 and
1.7E+308.The memory allocated for the double data
type is 8 bytes.
On most newer compilers, the data types double and
long double are the same.
42

 The maximum number of significant digitsthat is,

the number of decimal placesin float values is 6
or 7.
The maximum number of significant digits in
values belonging to the double type is 15.
The maximum number of significant digits is called
the precision.
float values are called single precision
double values are called double precision. 2

43

The string Type

The data type string is a programmer-defined type
and is not part of the C++ language. The C++
standard library supplies it.
A string is a sequence of zero or more characters.
Strings in C++ are enclosed in double quote marks.
A string with no characters is called a null or empty
string.
"William Jacob"
Mickey"
"
44

"" is the empty string.

Every character in a string has a relative
position in the string.
The position of the first character is 0, position
of the second character is 1, and so on.
The length of a string is the number of
characters in it.

45

Example :
String Position of a Character

Length of the String

in the Sting
"William Jacob"

Position of 'W' is 0.

13

Position of the first 'i' is 1.

Position of ' '
(the space) is 7.
Position of 'J' is 8.
Position of 'b' is 12.
Mickey" Position of M' is 0.

Position of 'i' is 1.
Position of 'c' is 2.
Position of 'k' is 3.
Position of 'e' is 4.
Position of 'y' is 5.

46

Other Data Types

Enumeration Data Types
Declaration
Assignment
Operations
Looping with Enumeration Types

Anonymous Data Types

The typedef statement
Namespaces
The string type
47

Enumeration Data Types

A data type is
A set of values together with
A set of operations on those values.

In order to define a new simple data type,

called enumeration type, we need:

A name for the data type.

A set of values for the data type.
A set of operations on the values.
48

Enumeration Data Types

C++ allows the user to define a new
simple data type by specifying:
Its name and the values
But not the operations.

The values that we specify for the data

type must be legal identifiers
The syntax for declaring an enumeration
type is:
enum typeName{value1, value2, ...};
49

Declaration of Enumerated
Types
Consider the colors of the rainbow as an
enumerated type:
enum rainbowColors =
{ red, orange, yellow, green,
blue, indigo, violate }
The identifiers between {
enumerators

} are called

The order of the declaration is

significant
red < orange < yellow
50

Declaration of Enumerated
Types
Why are the following illegal
declarations?
enum grades{'A', 'B', 'C', 'D', 'F'};
enum places{1st,
2nd, 3rd, 4th};
They do not have legal identifiers in the
list

What could you do to make them legal?

enum
enum

grades{A, B, C, D, F};
places{first, second, third, fourth};
51

Declaration of Enumerated
Types
As with the declaration of any object
Specify the type name
Followed by the objects of that type

Given:
enum daysOfWeek { Sun, Mon,
Tue,Wed, Thu, Fri, Sat }
Then we declare:
daysOfWeek Today, payDay, dayOff;
52

Assignment with Enumerated

Types
Once an enumerated variable has been
declared
It may be assigned an enumerated value
Assignment statement works as expected
payDay = Fri;

// note no quotes

// Fri is a value, a constant

Enumerated variables may receive only

values of that enumerated type
53

Operations on Enumerated Type

Objects
Incrementing variables of an
enumerated type
Do NOT use
NOR

workaday += 1;
today++;

Instead, use explicit type conversion

today = daysOfWeek (today + 1);
54

Operations on Enumerated Type

Objects
Comparison
normal, OK
in order of the enumeration definition

I/O
generally not possible to do directly
can be sort of done, indirectly

Used primarily for program control,

branching, looping
Possible to have functions return an
enumerated type
55

Looping with Enumeration Types

Use an enumerated type variable as the
loop control variable of a for loop
for (day
day
{
.
}

= Mon; day < Sat;

= static_cast<daysOfWeek>(day + 1))
. .
This works because the values are
represented internally as integers

56

Functions with Enumerated

Types
Enumeration type can be passed as
parameters to functions either by
value or by reference.
A function can return a value of the
enumeration type.
daysOfWeek nextDay (daysOfWeek d)
{
return (daysOfWeek) ((d + 1)%7);
}
57

Anonymous Data Types

Named Type
user defined type
declaration includes typedef
As with daysOfWeek or Boolean

Anonymous Type
does not have an associated type
enum (MILD, MEDIUM, HOT) salsa_sizzle;

variable declared without typedef

58

Anonymous Data Types

Disadvantages
Cannot pass an anonymous type as a parameter to a
function.
A function cannot return a value of an anonymous type.
Problems when:
enum {English, French, Spanish, German, Russian}
languages;

values
enum {English, French, Spanish, German, Same
Russian}
foreignLanguages;

used but variables

treated as non compatible types

languages = foreignLanguages; //illegal

59

The typedef statement

Syntax:
typedef

existing_type_name

new_type_name;

Example:
typedef int Boolean;
Does not really create a new type
is a valuable tool for writing self-documenting
programs

60

Namespaces
Recall use of
using namespace std;
Namespace is another word for scope
In C++ it is a mechanism
programmer creates a "named scope"

namespace std
{
int abs ( int );
. . .
}
61

Namespaces
Identifiers within a namespace can be
used outside the body of the
declaration only if
use scope resolution operator

x = std::abs(y);

a using declaration

using std::abs;
z = abs(q);

Note the distinction between

declaration and directive

a using directive

using namespace std;

p = abs(t);
62

Namespaces

We usually place the using directive in

global scope
All blocks { . . . } then have identifiers
available from the std namespace

63

The string type

We have used arrays of char to hold
"string" information
char name[30];
cin >> name;
There are some problems with doing this
There is no assignment statement
Must use strcpy (name, "Clyde");

Cannot do comparisons with < or == or >

Must use if (strcmp (s1, s2) == 0)

For all these must use #include <string.h>

64

The string type

C++ has a string type which bypasses all
the problems we've encountered
Gain these capabilities by
#include <string> // note no .h
Now we can use statements as shown:
string name = "Clyde";
if (title1 < title2)
str1 = str1 + "Day";
// assignment and concatenation

65

The string type

Some functions are available
string name, title;
name = "Alexander";
cout << name.length()<<endl;
cout << name.find('x') <<endl;
cout << name.substr(1,3) <<endl;
title = "Big Cheese";
title.swap(name);
Guess what will be the output of
cout << name<<endl;
these lines of code
66

ARITHMETIC OPERATORS AND OPERATOR

PRECEDENCE
Arithmetic Operators
+

addition

subtraction

multiplication

division

remainder (mod operator)

The operators +, -, *, and / can be used with both

integral and floating point data types, while % is used
only for integral data type to find the remainder in
67
ordinary division.

Arithmetic Expressions
3 +
2 +
5.6
x +

4
3 * 5
+ 6.2 * 3
2 * 5 + 6 / y

x and y are some unknown numbers

68

Unary operator: An operator that has only one

operand.
Binary Operator: An operator that two operands.
In the expression
5
has only one operand, which is 5 and so - acts as
a unary operator.
In the expression
+27
+ is a unary operator.

69

Further, in the expressions

3 + 4
23 - 45
both the operators + and are binary operators.

and + are both unary as well as binary arithmetic

operators.
*, /, and % are binary arithmetic operators.

70

Example 2-4
Arithmetic
Expression
2 + 5

Result Description

13 + 89

102

34 - 20

14

45 - 90

-45

2 * 7
5/2

14
2 In the division 5/2, the quotient is

2 and the remainder is 1.

Therefore, 5/2 evaluates to the
quotient, which is 2.
14 / 7

71

34 % 5

4 In the division 34/5, the quotient is 6 and

the remainder is 4. Therefore, 34%5

evaluates to the remainder, which is 4
-34 % 5 -4 In the division -34 / 5, the quotient is
-6 and the remainder is -4. Therefore,
-34 % 5 evaluates to the remainder,
which is -4.
34 % -5 4 In the division 34 / -5, the quotient
is 6 and the remainder is 4. Therefore
34 % -5 evaluates to the remainder,
which is 4.)
72

-34 % -5

4 % 6
and

-4 In the division -34 / -5, the quotient

is 6 and the remainder is -4.
Therefore, -34 % -5 evaluates to the
remainder, which is -4.)

4 In the division 4/6, the quotient is 0

the remainder is 4. Now 4 % 6 evaluates
to the remainder, which is 4.

73

Example
Expression

Result

5.0 + 3.5

8.5

3.0 + 9.4

12.4

16.3 - 5.2

11.1

4.2 * 2.5

10.50

5.0/2.0

2.5

74

Order of Precedence
The precedence rules of arithmetic operators are:
*, /, %
are at a higher level of precedence than
+, Operators *, /, and % have the same level of
precedence.
Operators + and - have the same level of
precedence.

75

 When operators are all on the same level, they are

performed from left to right.
To avoid confusion, the grouping symbol can be
used. For example,
3*7-6+2*5/4+6
means
(3 * 7) - 6 + ( ( 2 * 5) / 4 ) + 6
=
=
=
=
=

21
21
15
17
23

+
+

6 + (10 / 4) + 6
(Evaluate *)
6 + 2 + 6
(Evaluate /)
2 + 6
(Evaluate -)
6
(Evaluate first +)
(Evaluate +)
76

Character Arithmetic
8+7 = 15
'8' + '7' = 56 + 55 = 111
'8' + 7 = 56 + 7 = 63
'8' * '7' is undefined in the ASCII character data
set.

77

EXPRESSIONS

If all operands (that is, numbers) in an expression

are integers, the expression is called an integral
expression.
If all operands in an expression are floating-point
numbers, the expression is called a floating-point
or decimal expression.
An integral expression yields an integral result; a
floating-point expression yields a floating-point
result.

78

Example
Some C++ integral expressions:
2 + 3 * 5
3 + x - y / 7
x + 2 * (y - z) + 18

Example
Some C++ floating point expressions:
12.8 * 17.5 - 34.50
x * 10.5 + y - 16.2

79

Mixed Expressions
An expression that has operands of different data
types is called a mixed expression.
A

mixed expression contains both integers and

floating-point numbers.

Examples of mixed expressions

2 + 3.5
6 / 4 + 3.9
5.4 * 2 13.6 + 18 / 2

80

Rules to evaluate a mixed expression

1. When evaluating an operator in the mixed expression:
a. If the operator has the same types of operands (that is,
either both integers or both floating-point numbers), the
operator is evaluated according to the type of the
operands.
b. If the operator has both types of operands (that is, one is
an integer and the other is a floating-point number) then
during calculation the integer is changed to a floatingpoint number with the decimal part of zero and the
operator is evaluated. The result is a floating-point
number.

2. The entire expression is evaluated according to the

precedence rules; the multiplication, division, and
modulus operators are evaluated before the addition
and subtraction operators. Operators having the same
level of precedence are evaluated from left to right.
81
Grouping is allowed for clarity.

Example

(a) 3 / 2 + 5.0
= 1 + 5.0

(3 / 2 = 1)

= 6.0

(1 + 5.0 = 1.0 + 5.0= 6.0)

(b) 15.6 / 2 + 5
= 7.8 + 5
= 12.8

(15.6 / 2 = 15.6 / 2.0 = 7.8)

(7.8 + 5.0 = 12.8)

(c) 4 * 3 + 7 / 5 25.6
= 12 + 7 / 5 25.6
= 12 + 1 25.6
= 13 25.6
= -12.6

(4 * 3 = 12)
(7 / 5 = 1)

(12 + 1 = 13)
(13 25.6 = 13.0 25.6

= - 12.6)

82

 Implicit Type conversion

Cast operator (type conversion or type casting)
Syntax Cast operator
static_cast<dataTypeName>(expression)
Expression is evaluated and its value is converted to
value of the type specified by the dataTypeName.

83

Example

static_cast<int>(7.9) = 7
static_cast<int>(3.3) = 3
static_cast<double>(25) = 25.0
static_cast<double>(5+3) = static_cast<double>(8)
= 8.0
static_cast<double>(15)/2 = 15.0/2
= 15.0/2.0
= 7.5

84

static_cast<double>(15/2) = static_cast<double>(7)
= 7.0

static_cast<int>(7.8 + static_cast<double>(15)/2)
= static_cast<int>(7.8 + 7.5)
= static_cast<int>(15.3) = 15

static_cast<int>(7.8 + static_cast<double>(15/2)
= static_cast<int>(7.8 + 7.0)
= static_cast<int>(14.8)

= 14
85

x = 15
y = 23
z = 3.75
Expression

Value

static_cast<int>(7.9 + 6.7)

14

static_cast<int>(7.9)
+ static_cast<int>(6.7)

13

static_cast<double>(y / x) + z

4.75

static_cast<double>(y) / x + z

5.28333
86

INPUT

Storing data in the computers memory is a two step

process.
Instruct the computer to allocate memory.
Include statements in the program to put data into the allocated
memory.

87

Allocating Memory with Constants and

Variables
Named Constant: A memory location whose content is
not allowed to change during program execution.
Variable: A memory location whose content may
change during program execution.

88

Named Constant: The syntax to declare a

named constant is

const dataType identifier = value;

In C++, const is a reserved word.

Example
const double conversion = 2.54;
const int noOfStudents = 20;
const char blank = ' ';
const double payRate = 15.75;
89

Variable

The syntax for declaring one variable or multiple

variables is
dataType identifier, identifier, . . .;

Example
double amountDue;
int
char
int
string

counter;
ch;
x, y;
name;
90

1.

In C++, all identifiers must be declared

before they can be used. If we refer to an
identifier without declaring it, the compiler
will generate an error message indicating
that the identifier is not declared.

2. A data type is called simple if the variable (or

named constant) of that type can store only
one value at a time. For example, if x is an,
say, int variable. Then at a given time only
one value can be stored in x.

91

Putting Data into Variables

In C++ there are two ways that data can
be placed into a variable:
1. Using C++s assignment statement, and
2. Use input (read) statements.

92

Assignment Statement
The assignment statement takes the form
variable = expression;
The expression is evaluated and its value is assigned
to the variable on the left side.

In C++, = is called the assignment operator.

93

Examples 2-13
int I, J;
double sale;
char first;
string str;
I = 4;
J = 4 * 5 - 11;
sale = 0.02 * 1000;
first = 'D';
str = "It is a sunny day. ";

94

A C++ statement like

I = I + 2;
means evaluate whatever is in I, add two to it, and assign the new
value to the memory location I.
The sequence of C++ statements
I = 6;
I = I + 2;
and the statement
I = 8;
both assigns 8 to I.
The statement
I = 5;
is read 'I becomes 5', or 'I gets 5'.
Each time a new value is assigned to I, the old value is erased.

95

If the variables I, J, and K have been properly

declared, then the sequence of statements
I = 12;
I = I + 6;
J = I;
K = J / 2;
K = K / 3;
results in 'K becoming 3', that is, in K having the
value 3 stored in it.

96

 To save the value of an expression and use it in a

later expression, do the following:
1. Declare a variable of the appropriate data type. For
example, if the result of the expression is an integer,
declare an int variable.
2. Assign the value of the expression to the variable that
was declared using the assignment statement. This
action saves the value of the expression into the
variable.
3. Wherever the value of the expression is needed, use
the variable holding the value.

97

Example 2-14
int a, b, c, d;
int x, y;
Evaluate the expressions -b+(b2-4ac)and -b-(b2-4ac),
and assign the values of these expressions to x and
y, respectively.
The expression b2-4ac appears in both expressions
First calculate the value of this expression and save
its value in d.
Use the value of d to evaluate the expressions as
shown by the following statements:
d = b * b 4 * a * c;
x = -b + d;
y = -b d;

98

Declaration and Initializing Variables

Variables can be initialized when they are declared

int first, second;

char ch;
double x, y;
first = 13;
second = 10;
ch = ' ';
x = 12.6;
y = 123.456;
Equivalently, we can write the following C++ statements.
int first=13, second=10;
char ch=' ';
double x=12.6, y=123.456;

99

Input (Read) Statement

Syntax of cin together with >>:
cin>>variable>>variable. . .;
In C++, >> is called the extraction operator.

Suppose miles is a variable of the type double.

The statement
cin>>miles;
causes the computer to get a value of the type double and
place it in the memory cell miles.
100

 By using more than one variable in cin, more than

one value can be read at a time.
Suppose feet and inch are variables of the type
int. A statement like
cin>>feet>>inch;
gets two integers (entered at the keyboard) and
places them in the memory location feet and inch,
respectively.

101

Variable Initialization
Assignment statement
Read statement

int feet;
We can initialize feet to a value 35 either by using the
assignment statement

feet = 35;
or by executing the statement
cin>>feet;
C++ does not automatically initialize the variables when
102
they are declared.

Example 2-15
int one, two;
double z;
char ch;
string name;

1. one = 4;
2. two = 2 * one + 6;
3. z = (one + 1) / 2.0;
4. ch = 'A';
5. cin>>two;
6. cin>>z;
7. one = 2 * two + static_cast<int>(z);
8. cin>>name;
9. two = two + 1;
10. cin>>ch;
11. one = one + static_cast<int>(ch);
12. z = one z;

103

Suppose the input is

8 16.3 Goofy D
Before the execution
uninitialized.

of

statement

all

variables

are

104

1. one = 4;

Statement 1 stores 4 into one. So after the execution of statement

1, the values are

105

2. two = 2 * one + 6;

Statement 2 first evaluates the expression 2 * one + 6

(which evaluates to 14) and then stores the value of the
expression, that is, 14 into two. After the execution of
statement 2, the values are:

106

3. z = (one + 1) / 2.0;

Statement 3 first evaluates the expression (one + 1)/2.0 (which evaluates to 2.5)
and then stores the value of the expression into z. After the execution of statement
3, the values are:

107

4. ch = 'A';

Statement 4 stores the character 'A' into ch. After the execution of statement 4, the
values are:

108

5. cin>>two;

Statement 5 reads a number from the keyboard (which is 8) and stores the number
8 into two. After the execution of statement 5, the values are:

109

6. cin>>z;

Statement 6 reads a number from the keyboard (which is 16.3) and stores the
number 16.3 into z. After the execution of statement 6, the values are:

Note that the variable name is still undefined.

110

7. one = 2 * two + static_cast<int>(z);

Statement 7 first evaluates the expression 2 * two +

static_cast<int>(z) (which evaluates to 32) and then
stores the value of the expression, that is, 32 into one.
After the execution of statement 7, the values are:

111

8. cin>>name;

Statement 8 gets the next input from the keyboard (which is Goofy) and stores it
into name. After the execution of statement 8, the values are:

112

9. two = two + 1;

Statement 9 first evaluates the expression two + 1

(which evaluates to 9) and stores the value of this
expression, that is, 9 into two. After the execution of
statement 9, the values are:

113

10. cin>>ch;

Statement 10 reads the next input from the keyboard (which is D) and stores it into
ch. After the execution of statement 10, the values are:

114

11. one = one + static_cast<int>(ch);

Statement 11 first evaluates the expression one +

static_cast<int>(ch). Here static_cast<int>( 'D')
gives the collating sequence of the character D in
the character data set, which is 68 (in ASCII)). After
the execution of statement 11, the values are:

115

12. z = one z;

The statement 12 first evaluates the expression one z (= 100.0 16.3 =

83.7) and then stores the value of this expression, that is 83.7 into z. The value of
the variables after the execution of the last statement are:

116

INCREMENT AND DECREMENT OPERATORS

Increment operator - increment the value of a variable by 1
Decrement operator- decrement the value of a variable by 1.
Pre Increment: ++variable
Post Increment: variable++
Pre Decrement: --variable
Post Decrement: variable--

117

++count;
or
count++;
increments the value of count by 1.
--count;
or
count--;
decrements the value of count by 1.

118

1.
x = 5;
y = ++x;

After the second statement both x and y are 6.

2.
x = 5;
y = x++;

After the second statement y is 5 and x is 6.

Example 2-16
Suppose a and b are int variables.
a = 5;
b = 2 + (++a);
After the second statement a is 6 and b is 8.

119

OUTPUT
The syntax of cout together with << is
cout<<expression or manipulator<<expression or
manipulator...;

In C++, << is called the insertion operator.

expression (that is, expression) is evaluated and its value is
printed at the current cursor position on the screen.
manipulator manipulates the output. The simplest
manipulator is endl (the last character is the letter el), which
causes the cursor to move to the beginning of the next line.
This is called an output statement. Sometimes this is also
called a cout statement.
In C++, << is called the stream insertion operator.
Strings and expressions involving only one variable or a single
120
value are evaluated to itself.

Example 2-17
Statement

Output

1. cout<<29/4;

2. cout<<"Hello there. ";

3. cout<<12;

Hello there.

12

4. cout<<"4+7";

4+7

5. cout<<4+7;

11

6. cout<<"A";

7. cout<<"4 + 7 = "<<4 + 7;

8. cout<<2+3*5;

4 + 7 = 11

17

9. cout<<"Hello \nthere. ";

Hello

there.
\n is called new line escape sequence.
\ (back slash) is called the escape character.

121

The output of the C++ statement

cout<<a;
is meaningful provided the variable a has been
given a value. For example, the sequence of C++
statements,
a = 45;
cout<<a;
will produce an output of 45.

122

Example 2-18
int a, b, c, d;
a = 65 ;

//Line 1

b = 78 ;

//Line 2

cout<<29/4<<endl; //Line 3
cout<<3.0/2<<endl;

//Line 4

cout<<"Hello there.\n";

//Line 5

cout<<7<<endl; //Line 6
cout<<3+5<<endl;

//Line 7

cout<<"3+5"; //Line 8
cout<<endl;

//Line 9

cout<<2+3*6<<endl;
cout<<"a"<<endl;

//Line 10

//Line 11

cout<<a<<endl; //Line 12
cout<<b<<endl; //Line 13
cout<<c<<'\n'; //Line 14
cout<<d;

//Line 15

cout<<endl;

//Line 16

123

Output of Statement at
7

Line 3

1.5 Line 4
Hello there. Line 5
7

Line 6

Line 7

3+5 Line 8
20 Line 10
a

Line 11

65 Line 12
78 Line 13
6749684 Line 14
4203005 Line 15

124

The new line character, '\n'.

cout<<"Hello there.";
cout<<"My name is Goofy.";
Output
Hello there.My name is Goofy.
Now consider the following C++ statements.
cout<<"Hello there.\n";
cout<<"My name is Goofy.";
Output
Hello there.
My name is Goofy.

125

When \n is encountered in the string, the cursor is

positioned at the beginning of the next line.
\n may appear anywhere in the string.
The output of the statement
cout<<"\n";
is equivalent to the output of the statement
cout<<endl;
which is equivalent to the output of the statement
cout<<'\n';

126

The output of the sequence of statements:

cout<<"Hello there.\n";
cout<<"My name is Goofy.";
is equivalent to the output of the sequence
statements:
cout<<"Hello there."<<endl;
cout<<"My name is Goofy.";

127

Example

cout<<"Hello there.\nMy name is Goofy.";

Or
cout<<"Hello there.";
cout<<"\nMy name is Goofy.";
or
cout<<"Hello there.";
cout<<endl<<"My name is Goofy.";
In each case the output is
Hello there.
My name is Goofy.
128

Example 2-20

The output of the following C++ statement

cout<<"Count...\n....1\n.....2\n......3";
or
cout<<"Count..."<<endl<<"....1"<<endl
<<".....2"<<endl<<"......3";
Is
Count...
....1
.....2
......3

129

Example

To output the following sentence in one line as part of a message:

It is sunny, warm, and not a windy day. Let us go golfing.

We can use any of the following statements:

cout<<"It is sunny, warm, and not a windy day. ";

cout<<"Let us go golfing."<<endl;

or

cout<<"It is sunny, warm, and not a windy day. "

<<"Let us go golfing."<<endl;
130

The following statement is illegal in C++.

cout<<"It is sunny, warm, and not a windy day.
Let us go golfing."<<endl;

The return (or Enter) key on your keyboard cannot be part of

the string.

131

Example
The output of the statement
cout<<"The newline escape sequence is \\n"<<endl;
Is
The new line escape sequence is \n
The output of the statement
cout<<"The tab character is represented as \'\\t\'"<<endl;
is
The tab character is represented as '\t
The output of the statement
cout<<"The string \"Sunny\" contains five characters\n";
is
The string "Sunny" contains five characters

132

Prepr

ocessor Directives
Only a small number of operations are explicitly defined in C++.
Many of the functions and symbols that are necessary to run a C++
program are provided as a collection of libraries.
Every library has a name and is referred as a header file. For example,
the descriptions of the functions needed to perform I/O are contained in
the header file iostream.
The descriptions of some very useful mathematics functions such as
power, absolute, sine, etc., are contained in the header file cmath.
Preprocessor directives are commands supplied to the preprocessor.
All preprocessor commands begin with #.
There is no semicolon at the end of these commands since these are
preprocessor commands not C++ commands.
133

The general syntax to include a header file

(provided by the SDK) in a C++ program is

#include <headerFileName>
The preprocessor directive
#include <iostream>
causes the preprocessor to include the header file
iostream in the program.

134

In Standard C++, header files have the file

extension .h
In Standard C++, the descriptions of the functions
needed to perform I/O are contained in the header
file iostream.h

#include <iostream.h>
#include <math.h>

135

136

Using cin and cout in a Program and

namespace
One way to use cin and cout in a program is to refer
them as std::cin and std::cout.
Another option is to include the following statement
in your program:
using namespace std;
The using statement appears after the statement
#include <iostream>.
137

Using the string Data Type in a Program

To use the string data type in a program, your
must include the following preprocessor directive:
#include <string>

138

Program Style and Form

The Program Part
Every C++ program has a function main.
The basic parts of the function main are:
1. The heading
2. Body of the function
The heading part has the following form
typeOfFunction main(argument list)

139

The statement
int main(void)
means that the function main returns a value of the
type int and it
has no arguments.
The previous statement is equivalent to statement
int main()

It is not necessary to put word the void in

parentheses, but the parentheses are still needed.
140

The body of the function is enclosed between

{ and } and has two types of statements.
Declaration statements.
Executable statements.

141

Declaration Statements
int

a, b, c;

double

x, y;

Variables (or identifies) can be declared anywhere in the

program, but they must be declared before they can be
used.

Executable Statements
Example 2-24
Executable statements:
a = 4; //assignment statement
cin>>b; //input statement
cout<<a<<endl<<b<<endl; //output statement

142

Syntax
Errors in syntax are detected during compilation.

int x;
int y

//Line 1
//Line 2; syntax error

double z; //Line 3
y = w + x;//Line 4 ; syntax error

143

Use of Blanks
In C++, one or more blanks are used to separate
numbers when data is input.
Blanks are also used to separate reserved words and
identifiers from each other and other symbols.
Commas are used to separate items in a list.

Use of Semicolons, Brackets, and Commas

All C++ statements terminate with a semicolon.
The semicolon is also called a statement terminator.
{ and } are not C++ statements.

144

Semantics
It is quite possible for you to eradicate all syntax errors
in a program and still not have it run. And if it runs it
still may not do what you meant it to do. For example,
2 + 3 * 5
and
(2 + 3) * 5
are both syntactically correct expressions, but have
different meanings.

145

Form and Style

Consider the
variables.

following

two

ways

of

declaring

int feet, inch;

double x, y;
or
int a,b;double x,y;

146

Blank spaces
int a,b,c;
int

a,

b,

c;

The blanks between the identifiers in the second

statement are meaningless.
In the statement,
inta,b,c;
no blank between the t and a changes the reserved
word int and the identifier a into a new identifier
inta.
147

Documentation
Comments
Single line comments
Single line comments begin with // anywhere in the
line.

Multiple line comments.

Multiple line comments are enclosed between /*
and */.

148

Naming Identifiers
const double a = 2.54;

//conversion constant

double x;

//variable to hold centimeters

double y;

//variable to hold inches

x = y * a;
Consider the following
const double conversion = 2.54;
double centimeters;
double inches;
centimeters = inches * conversion;
Run-together-word
inchperfoot
Run-together-words can be handled either by using CAPS for the beginning of
each new word or underscore just before the new word.
We could use
either

inchPerFoot

or inch_per_foot.

149

Prompt Lines
cout<<"Please enter a number between 1 and 10 and"
<<" press the return key"<<endl;
cin>>num;

When these two statements execute in the order

given, first the cout statement causes the following
line of text to appear on the screen:
Please enter a number between 1 and 10 and press the return
key

After seeing this line, users know that they must

enter a number and press the return key.
150

MORE ON ASSIGNMENT STATEMENTS

Assignment Statements
Simple assignment statements.
Compound assignment statements.

151

Compound assignment operator

op=
where op is any of the arithmetic operators.
Using the compound assignment operator, the
simple assignment statement
variable = variable op (expression);
can be rewritten as
variable op= expression;
and is called the compound assignment statement.
152

Example 2-25
Simple Assignment

Compound Assignment

Statement

Statement

I = I + 5;

I += 5;

counter = counter + 1;
sum = sum + number;

counter += 1;
sum += number;

amount=amount*(interest+1);

x = x / ( y + 5);

amount *= interest + 1;

/= y + 5;

153

PROGRAMMING EXAMPLE: CONVERT

LENGTH
Write a program that takes as input a given
length expressed in feet and inches. It then
converts and outputs the length in centimeters.
Input: Length in feet and inches.
Output: Equivalent length in centimeters.

154

Problem Analysis and Algorithm Design

The lengths are given in feet and inches, and you
need to find the equivalent length in centimeters.
One inch is equal to 2.54 centimeters. The first thing
the program needs to do is convert the length given
in feet and inches to all inches. Then you can use the
conversion formula, 1 inch = 2.54 centimeters, to
find the equivalent length in centimeters. To convert
the length from feet and inches to inches, you
multiply the number of feet by 12, as 1 foot is equal
to 12 inches, and add the given inches.
For example, suppose input is 5 feet and 7 inches.
Then total inches are given by
totalInches = 12 * feet + inches
= 12 * 5 + 7 = 67

155

We now apply the conversion formula, that is, 1 inch

= 2.54 centimeters to find the length in
centimeters.
centimeters = totalInches * 2.54
= 67 * 2.54
= 170.18
The above discussion translates into the following
algorithm:
1. Get the length in feet and inches.
2. Convert the length into total inches.
3. Convert total inches into centimeters.
4. Output centimeters.

156

Variables
int feet;

//variable to hold given feet

int inchs;

//variable to hold given inches

int totalInches; //variable to hold total inches

double centimeters;

// variable to hold length

//in centimeters.
Named Constant
const double conversion = 2.54;
const int inchesPerFoot = 12;

157

Main Algorithm
1. Prompt the user for the input. (Without a prompt
line, the user will be staring at a blank screen
and will not know what to do.)
2. Get the data.
3. Echo the inputthat is, output what the program
read as input. (Without this step, after the
program has executed, you will not know what
the input was.)
4. Find the length in inches.
5. Output the length in inches.
6. Convert the length to centimeters.
7. Output the length in centimeters.

158

Putting it Together
The program will begin with comments that document its purpose and
functionality.
There is both input to this program (the length in feet and inches) and output (the
equivalent length in centimeters), you will be using system resources for
input/output.
The program will use input statements to get data into the program and output
statements to print the results.
The data will be entered from the keyboard and the output will be displayed on
the screen, the program must include the header file iostream.
The first statement of the program, after the comments as described above, will
be the preprocessor directive to include this header file.

159

This program requires two types of memory locations

for data manipulation: named constants and variables.
Named constants are usually placed before the function
main so that they can be used throughout the program.
This program has only one function, the function main,
which will contain all of the programming instructions
in its body.
The program needs variables to manipulate data, and
these variables will be declared in the body of the
function main.
The body of the function main has the following form:
int main ()
{
declare variables
statements
return 0;
}

160

In order to write the complete C++ program:

1. Begin the program with comments for
documentation.
2. Include header files, if any are used in the program.
3. Declare named constants, if any.
4. Write the definition of the function main.

161

Complete Program Listing in ANSI/ISO Standard C+

+
//*************************************************
//

Program Convert: This program converts

// measurements in feet and inches into centimeters

// using the approximation that 1 inch is equal to
// 2.54 centimeters.
//*************************************************
//header file
#include <iostream>
using namespace std;
//named constants
const double conversion = 2.54;
const int inchesPerFoot = 12 ;

162

int main ()
{
//declare variables
int feet;
int inches;
int totalInches;
double centimeter;
//Statements: Step 1 - Step 7
cout<<"Enter two integers, one for feet, "
<<"one for inches: ";
cin>>feet>>inches;

//Step 1

//Step 2

cout<<endl;
cout<<"The numbers you entered are "<<feet
<<" for feet "<<"and "<<inches
<<" for inches. "<<endl;

//Step 3

163

totalInches = inchesPerFoot * feet + inches;

//Step 4
cout<<endl;
cout<<"The total number of inches = "
<<totalInches<<endl;

//Step 5

centimeter = conversion * totalInches;

//Step 6
cout<<"The number of centimeters = "
<<centimeter<<endl;

//Step 7

return 0;
}

164

Sample Run: In this sample run, the user

input is in red
Enter two integers, one for feet, one for inches: 15 7
The numbers you entered are 15 for feet and 7 for inches.
The total number of inches = 187
The number of centimeters = 474.98

165

Complete Program Listing in Standard C++

//*************************************************
//

Program Convert: This program converts

// measurements in feet and inches into centimeters

// using the approximation that 1 inch is equal to
// 2.54 centimeters.
//*************************************************
//header file
#include <iostream.h>
//named constants
const double conversion = 2.54;
const int inchesPerFoot = 12 ;

166

int main ()
{
//declare variables
int feet;
int inches;
int totalInches;
double centimeter;
//Statements: Step 1 - Step 7
cout<<"Enter two integers, one for feet, "
<<"one for inches: ";

//Step 1

cin>>feet>>inches; //Step 2
cout<<endl;
cout<<"The numbers you entered are "<<feet
<<" for feet "<<"and "<<inches
<<" for inches. "<<endl;

//Step 3

167

totalInches = inchesPerFoot * feet + inches;

//Step 4
cout<<endl;
cout<<"The total number of inches = "
<<totalInches<<endl;

//Step 5

centimeter = conversion * totalInches;

//Step 6
cout<<"The number of centimeters = "
<<centimeter<<endl;

//Step 7

return 0;
}

168

PROGRAMMING EXAMPLE: MAKE

CHANGE
Write a program that takes as an input any
change expressed in cents. It then computes
the number of half-dollars, quarters, dimes,
nickels and pennies to be returned, if you are
to return as many half-dollars as possible, then
quarters, dimes, nickels, and pennies in that
order.
For example 483 cents should be returned as 9
half-dollars, 1 quarter, 1 nickel, and 3 pennies.
Input: Change in cents.
Output: Equivalent change in half-dollars,
quarters, dimes, nickels and pennies.
169

Problem Analysis and Algorithm Design

Suppose the change is 646 cents.
1. Change = 646
2. Number of Half-dollars = 646/50 = 12
3. Remaining Change = 646 % 50 = 46
4. Number of Quarters = 46 / 25 = 1
5. Remaining Change = 46 % 25 = 21
6. Number of Dimes = 21 / 10 = 2
7. Remaining Change = 21 % 10 = 1
8. Number of Nickels = 1 / 5 = 0
9. Remaining Change = 1 % 5 = 1
170

This discussion translates into the following

algorithm.
1. Get the change in cents.
2. Find the number of half-dollars.
3. Calculate the remaining change.
4. Find the number of quarters.
5. Calculate the remaining change.
6. Find the number of dimes.
7. Calculate the remaining change.
8. Find the number of nickels.
9. Calculate the remaining change.
10. The remaining change is the number of
171
pennies.

Variables
From the above steps it appears that we will need variables to hold half-dollars,
quarters and so on.
Since we are not going to use the values of half-dollars, quarters and so on in
any calculation, we can simply output them. The only thing that keeps changing
is the change.
int change;
Named Constants
const
const
const
const

int
int
int
int

Halfdollar = 50;
Quarter = 25;
Dime = 10;
Nickel = 5;

172

Main Algorithm
1. Prompt the user for input.
2. Get input.
3. Echo the input by displaying the entered
change on the screen.
4. Compute and print the number of half-dollars.
5. Calculate the remaining change.
6. Compute and print the number of quarters.
7. Calculate the remaining change.
8. Compute and print the number of dimes.
9. Calculate the remaining change.
10.

Compute and print the number of nickels.

11.

Calculate the remaining change.

12.

Print the remaining change.

173

Complete Program Listing

// ****************************************************
// Program Make Change: Given any amount of change
// expressed in cents, this program computes the number
// of half-dollars, quarters, dimes, nickels, and
// pennies to be returned, returning as many
// half-dollars as possible, then quarters, dimes,
// nickels, and pennies in that order.
//*****************************************************
//header file
#include <iostream>
using namespace std;
//named constants
const int Halfdollar = 50;
const int Quarter

= 25;

const int Dime = 10;

const int Nickel = 5;

174

int main()
{
//declare variable
int change;
//Statements: Step 1 Step 12
cout<<"Enter change in cents: ";
cin>>change;

//Step 1

//Step 2

cout<<endl;
cout<<"The change you entered is "<<change<<endl; //Step 3
cout<<"The number of half-dollars to be returned "
<<"are "<<change / Halfdollar<<endl;//Step 4
change = change % Halfdollar;

//Step 5

cout<<"The number of quarters to be returned are "

<<change / Quarter<<endl; //Step 6

175

change = change % Quarter;

//Step 7

cout<<"The number of dimes to be returned are "

<<change / Dime<<endl;
change = change % Dime;

//Step 8
//Step 9

cout<<"The number of nickels to be returned are "

<<change / Nickel<<endl;
change = change % Nickel;

//Step 10
//Step 11

cout<<"The number of pennies to be returned are "

<<change<<endl;

//Step 12

return 0;
}

176

Sample Run: In this sample run, the user input is

red:
Enter change in cents: 583
The change you entered is 583
The number of half-dollars to be returned are 11
The number of quarters to be returned are 1
The number of dimes to be returned are 0
The number of nickels to be returned are 1
The number of pennies to be returned are 3

177

INTEGRAL DATA TYPEIl data types

178

Int Data Type

Integers are whole numbers (without any
fractional Part)

Ex:
-6728,

-67, 0, 78, 36782, +763,...

*Positive integers do not have to have a +

sign in front of them.
*No commas are used within an integer.
*In C++ commas are reserved for separating
items in a list. So 36,782 would be
interpreted as two integers 36 and 782.
179

180

/* PROGRAM THAT ILLUSTRATES

INT DATA TYPE*/
#include<iostream.h>
void main()
{
int n=45;
cout<<the integer value is <<n;
getch();
}
NOTE: n is an integer number which holds 2
bytes of memory. the value ranges from
-32768 to +32767.
181

182