Basics of Programming

Lecture 2
Introduction to Programming
 Outside of a Computer

Session 2 2
 Inside of a Computer

Session 2 3
 Simplistic View of a Computer

Session 2 4
Very Simplistic View of a Computer

Location 0
Location 1
Location 2 Each location is
Location 3
1 byte of memory

CPU Location 4
1 byte = 8 bits
Location 5

Each bit is an electric

impulse carrying 1 or 0.

This simplistic view is enough to explain the basic concepts

of programming to students
Session 2 5
 Value
• The only task a computer can do is arithmetic e.g.
multiplying, dividing, subtracting, etc.
• Therefore, everything in the computer is represented as a
value
- Numbers, letters, characters, etc are all represented as values
• Values could change depending on their nature. For
example
- the temperature today is different from the temperature yesterday
- The number of cars inside Lahore is different then the number of in
cars Islamabad.

Session 2 6
 Variable
• To store a value inside a computer a
‘variable’ is used.
• A variable is a space in the memory to store

a value.
• This space is reserved until the variable is

required.

Session 2 7
 What Makes a Variable
• Variable has three important characteristics:
- Type
• How much memory do a variable need.
- This information is determined by a type.
- Name
• How to differentiate a variable with another variable of the
same type.
- Name refers to the memory location assigned to this variable.
- Value
• What is the value?
- The actual value contained by a variable.

Session 2 8
 An Example of a Variable

Type of the variable is integer (written as “int” in C++)

int temperature = 35

A name of the variable

An initial value of the variable

Session 2 9
 Example of a Variable
(Memory View)
int temperature = 35
00000000 Location 0
Locations 0 - 3 are collectively 00000000 Location 1
called as ‘temperature’ 00000000 Location 2
00100011 Location 3
Location 4
100011 is the binary equivalent of 35 Location 5

Session 2 10
 Changing the Value of Variable
• Lets change the value of ‘temperature’.
temperature = 45902

00000000 Location 0
Locations 0 - 3 are collectively 00000000 Location 1
called as ‘temperature’ 10110011 Location 2
01001110 Location 3
Location 4
Location 5
1011001101001110 is the binary equivalent of 45902

Session 2 11
 Type of a Variable
• Among other advantages a ‘type’ binds the
memory to a variable name.
• The type int is of 4 bytes in C++.

• Therefore, it can hold maximum of

2,147,483,647 value.
• It can also hold values in negative down to

-2,147,483,648.
Session 2 12
 Initializing Variables
• Declaring a variable does not give it a value
- Giving a variable its first value is initializing the variable
• Variables are initialized in assignment statements

double mpg; // declare the variable

mpg = 26.3; // initialize the variable
• Declaration and initialization can be combined
using two methods
- Method 1
double mpg = 26.3, area = 0.0 , volume;
- Method 2
double mpg(26.3), area(0.0), volume;
 Variable for Real Numbers
• int cannot hold a real value.
• Therefore, a type “double” is used to hold real
values.
• Double takes 8 bytes of memory instead of 4 bytes
of a double.
• Out of the 8 bytes in a double 4 bytes are used to
hold the value before the decimal point and 4
bytes for the value after the decimal point.

ession 2 14
Relative Comparison of int and double
int numPeople = 2;

Reserves 32 bits (4 bytes)

and sets the value stored
in that space to 2. The name
‘numPeople’ is associated with
this space.

double bill = 32.45;

Reserves 64 bits (8 bytes)

and sets the value stored
in that space to 32.45. The name
‘bill’ is associated with
this space.

Session 2 15
Session 2 16
 Manipulating Variables
• Assignment Statement
- In Mathematics the value x = x + 1 is not
possible why?
- In C++ x = x +1 is possible because “=” is an
assignment operator and not an equality
operator.
- Assignment operator means that the contents of
the right hand side is transferred to the memory
location of the left hand side.

Sessio 2 17
 Assignment Statement

x = 5671

5671 is written at the memory location reserved for x

Session 2 18
 Constants
• Constants are values which cannot be
modified e.g. the value of Pi
• To declare a constant in C++, we write a

keyword “const” before the variable type.

const double pi = 3.14;

Session 2 19
 Reserved Words
•Some names cannot be declared as variable names
because they are reserved words in C++

Session 2 20
 Manipulating Values
• Mathematical Operators
- Common mathematical operators are available
in C++ for manipulating values e.g. addition(+),
subtraction(-), multiplication(*), division(/),
and modulus (%).
•C++ has many other operators also which
we will study in due course.

Sessio 2 21
FEEDBACK QUIZ

Session 2 22
 What is result of the following
expression?
4*3+8/2+2*4

1a) 2.75
1b) 24
1c) 96
1d) 36
fq:1?
 Arithmetic Expression Evaluation

•To evaluate an arithmetic expression two

concepts needs to be understood
- Operator Precedence
•Operator precedence controls the order in which
operations are performed
- Operator Associativity
•The associativity of an operator specifies the order
in which operations of the same precedence are
performed
Session 2 24
 Operator Precedence and
Associativity
• Operators Precedence and Associativity
for C++ is following

1. *, /, %  Do all multiplications, divisions

and remainders from left to right.
2. +, -  Do additions and subtractions from
left to right.

ession 2 25
 Evaluating an Expression
6+2*3/6
• Three operators are in this expression.
• However, * and / both have the same precedence and + has
lower precedence then these two.
• * and / will be evaluated first but both have the same
precedence level.
• Therefore, operator associatively will be used here to
determine the first to get evaluated i.e. left to right.
• The left most sub expression will be evaluated followed by
the next right one and so on.

Session 2 26
 Primitive Data Types
• So far the variable types that we have
studied are primitive data types.
• Primitive data types only have a memory

space for storing values.

Session 2 27
 Type char
• Computers process character data too
• char

- Short for character

- Can be any single character from the keyboard

• To declare a variable of type char:

•
char letter;
Slide 2- 28
 char constants
• Character constants are enclosed in single quotes

char letter = 'a';

• Strings of characters, even if only one character

is enclosed in double quotes
- "a" is a string of characters containing one character
- 'a' is a value of type character

Slide 2- 29
 Reading Character Data
• cin skips blanks and line breaks looking for data
• The following reads two characters but skips
any space that might be between

char symbol1, symbol2;

cin >> symbol1 >> symbol2;

• User normally separate data items by spaces

J D
• Results are the same if the data is not separated
by spaces
JD
 Type bool
• bool is a new addition to C++
- Short for boolean
- Boolean values are either true or false

• To declare a variable of type bool:

bool old_enough;
 Manipulator
•Manipulators are instructions to the output
stream that modify the output in various ways
-endl is a manipulator that causes a linefeed to
be inserted into the stream
-cout<<“Sample text”<<endl;
-setw is another manipulator that sets the field
width of the output
 Casting
•Converting a value of one type into another
type
•Manual Casting
• static_cast<double> (intVar)
•Automatic Casting
• Automatic conversion of lower order type to higher
order type when two operands of different types are
encountered in the same expression
 Operator Shorthand
• Some expressions occur so often that C++
contains to shorthand operators for them
• All arithmetic operators can be used this way
- += count = count + 2; becomes
count += 2;
- *= bonus = bonus * 2; becomes
bonus *= 2;
- /= time = time / rush_factor; becomes
time /= rush_factor;
- %= remainder = remainder % (cnt1+ cnt2); becomes
remainder %= (cnt1 + cnt2);
INPUT AND OUTPUT

33
 Input and Output
• A data stream is a sequence of data
- Typically in the form of characters or numbers

• An input stream is data for the program to use

- Typically originates
• at the keyboard
• at a file

• An output stream is the program’s output

- Destination is typically
• the monitor
• a file
 Output using cout

• cout is an output stream sending data to the monitor

• The insertion operator "<<" inserts data into cout
• Example:
cout << number_of_bars << " candy bars\n";
- This line sends two items to the monitor
• The value of number_of_bars
• The quoted string of characters " candy bars\n"
- Notice the space before the ‘c’ in candy
- The ‘\n’ causes a new line to be started following the ‘s’ in bars

• A new insertion operator is used for each item of output

Slide 2- 35
 Examples Using cout
• This produces the same result as the previous sample

cout << number_of_bars ;

cout << " candy bars\n";
• Here arithmetic is performed in the cout statement
cout << "Total cost is $" << (price + tax);

• Quoted strings are enclosed in double quotes ("Walter")

- Don’t use two single quotes (')
• A blank space can also be inserted with

cout << " " ;

if there are no strings in which a space is desired as

in " candy bars\n"
 Include Directives
• Include Directives add library files to our programs

- To make the definitions of the cin and cout available to

the program:

#include <iostream>

• Using Directives include a collection of defined names

- To make the names cin and cout available to our program:

using namespace std;

 Escape Sequences
• Escape sequences tell the compiler to treat characters
in a special way
• '\' is the escape character
- To create a newline in output use
\n - cout << "\n";
or the newer alternative
cout << endl;

- Other escape sequences:

\t -- a tab
\\ -- a backslash character
\" -- a quote character
 Formatting Real Numbers
• Real numbers (type double) produce a variety of outputs

double price = 78.5;

cout << "The price is $" << price << endl;

- The output could be any of these:

The price is $78.5
The price is $78.500000
The price is $7.850000e01
- The most unlikely output is:
The price is $78.50
 Showing Decimal Places
• cout includes tools to specify the output of type double

• To specify fixed point notation

- setf(ios::fixed)
• To specify that the decimal point will always be shown
- setf(ios::showpoint)
• To specify that two decimal places will always be shown
- precision(2)

• Example: cout.setf(ios::fixed); \\scientific

cout.setf(ios::showpoint);
cout.precision(2);
cout << "The price is "
<< price << endl;
 Input Using cin
• cin is an input stream bringing data from the keyboard
• The extraction operator (>>) removes data to be used
• Example:
cout << "Enter the number of bars in a package\n";
cout << " and the weight in ounces of one bar.\n";
cin >> number_of_bars;
cin >> one_weight;
• This code prompts the user to enter data then
reads two data items from cin
- The first value read is stored in number_of_bars
- The second value read is stored in one_weight
- Data is separated by spaces when entered
 Reading Data From cin
• Multiple data items are separated by spaces
• Data is not read until the enter key is pressed
- Allows user to make corrections

• Example:
cin >> v1 >> v2 >> v3;

- Requires three space separated values

- User might type
34 45 12 <enter key>
 Designing Input and Output
• Prompt the user for input that is desired
- cout statements provide instructions

cout << "Enter your age: ";

cin >> age;
• Notice the absence of a new line before using cin
• Echo the input by displaying what was read
- Gives the user a chance to verify data

cout << age << " was entered." << endl;

 Sequential Programs

Session 2 Object-Oriented Programming 44

 Your Program is Like a Network
of Roads in a City

Session 2 Object-Oriented Programming 45

 Simple Flow of Control

• Flow of control
- The order in which statements are executed

• Branch
- Lets program choose between two alternatives
 Branching Example

Session 2 Object-Oriented Programming 47

 Branch Example
•To calculate hourly wages there are two
choices
- Regular time ( up to 40 hours)
• gross_pay = rate * hours;

- Overtime ( over 40 hours)

• gross_pay = rate * 40 + 1.5 * rate * (hours - 40);

- The program must choose which of these

expressions to use
 Designing the Branch

• Decide if (hours >40) is true

- If it is true, then use
gross_pay = rate * 40 + 1.5 * rate *
(hours -
40);
- If it is not true, then use
gross_pay = rate * hours;

Slide 2- 49
 Implementing the Branch
• if-else statement is used in C++ to perform
a
branch

- if (hours > 40)

gross_pay = rate * 40 + 1.5 * rate *
(hours -
40);
- else
- gross_pay = rate * hours;
 Boolean Expressions
• Boolean expressions are expressions that are
either true or false
• comparison operators such as '>' (greater than)
are used to compare variables and/or numbers
- (hours > 40) Including the parentheses, is the
boolean expression from the wages example
- A few of the comparison operators that use two
symbols (No spaces allowed between the symbols!)
• >= greater than or equal to
• != not equal or inequality
• = = equal or equivalent
 if-else Flow Control (1)

• if (boolean expression)
true statement
else
false statement
• When the boolean expression is true

- Only the true statement is executed

• When the boolean expression is false
- Only the false statement is executed
 if-else Flow Control (2)
• if (boolean expression)
{
true statements
}
else
{
• false statements
}
• When the boolean expression is true
- Only the true statements enclosed in { } are executed
• When the boolean expression is false
- Only the false statements enclosed in { } are executed
 AND
• Boolean expressions can be combined into
more complex expressions with
- && -- The AND operator
• True if both expressions are true
• Syntax: (Comparison_1) && (Comparison_2)
• Example: if ( (2 < x) && (x < 7) )
- True only if x is between 2 and 7
- Inside parentheses are optional but enhance meaning
 OR
• | | -- The OR operator (no space!)
- True if either or both expressions are true

• Syntax: (Comparison_1) | | (Comparison_2)

• Example: if ( ( x = = 1) | | ( x = = y) )
- True if x contains 1
- True if x contains the same value as y
- True if both comparisons are true
 NOT
• ! -- negates any boolean expression
- !( x < y)
• True if x is NOT less than y

- !(x = = y)
• True if x is NOT equal to y

• ! Operator can make expressions difficult to

understand…use only when appropriate
 Inequalities
• Be careful translating inequalities to C++
• if x < y < z translates as

if ( ( x < y ) && ( y < z ) )

NOT

if ( x < y < z )
 Pitfall: Using = or ==
• ' = ' is the assignment operator
- Used to assign values to variables
- Example: x = 3;
• '= = ' is the equality operator
- Used to compare values
- Example: if ( x == 3)
• The compiler will accept this error:
if (x = 3)
but stores 3 in x instead of comparing x and 3
- Since the result is 3 (non-zero), the expression is true
 Compound Statements
• A compound statement is more than one
statement enclosed in { }
• Branches of if-else statements often need to
execute more that one statement
• Example: if (boolean expression)
{
true
statements
else}
{
false
statements
}
 Branches Conclusion
• Can you
- Write an if-else statement that outputs the word
High if the value of the variable score is greater
than 100 and Low if the value of score is at most
100? The variables are of type int.

- Write an if-else statement that outputs the word

Warning provided that either the value of the variable
temperature is greater than or equal to 100, or the
of the variable pressure is greater than or equal to
200, or both. Otherwise, the if_else sttement outputs
the word OK. The variables are of type int.
 Simple Loops

Session 2 Object-Oriented Programming 61

 Simple Loops
• When an action must be repeated, a loop is used
• C++ includes several ways to create loops
• We start with the while-loop
• Example: while (count_down > 0)
{
cout << "Hello ";
count_down -= 1;
}
• Output: Hello Hello Hello
when count_down starts at 3
 While Loop Operation
• First, the boolean expression is evaluated
- If false, the program skips to the line following the
while loop
- If true, the body of the loop is executed
• During execution, some item from the boolean expression
is changed
- After executing the loop body, the boolean
expression is checked again repeating the process
until the expression becomes false
• A while loop might not execute at all if the
boolean expression is false on the first check
 while Loop Syntax
• while (boolean expression is true)
{
statements to repeat
}
- Semi-colons are used only to end the statements
within the loop
• While (boolean expression is true)
statement to repeat
 do-while loop
• A variation of the while loop.
• A do-while loop is always executed at least once
- The body of the loop is first executed
- The boolean expression is checked after the body
has been executed
• Syntax: do
{
statements to repeat

} while (boolean_expression);
 Increment/Decrement
• Unary operators require only one operand
- + in front of a number such as +5
- - in front of a number such as -5
• ++ increment operator
- Adds 1 to the value of a variable
x ++;
is equivalent to x = x + 1;
• -- decrement operator
- Subtracts 1 from the value of a variable
x --;
is equivalent to x = x - 1;
 Sample Program
• Bank charge card balance of $50
• 2% per month interest

• How many months without payments before

your balance exceeds $100
• After 1 month: $50 + 2% of $50 = $51
• After 2 months: $51 + 2% of $51 = $52.02
• After 3 months: $52.02 + 2% of $52.02 …
 Infinite Loops
• Loops that never stop are infinite loops
• The loop body should contain a line that will
eventually cause the boolean expression to
become false
• Example: Print the odd numbers less than 12
x = 1;
while (x != 12)
{
cout << x << endl;
x = x + 2;
}
• Better to use this comparison: while ( x < 12)
 Exercise
• Can you
- Show the output of this code if x is of type int?
x = 10;
while ( x > 0)
{
cout << x << endl;
x = x - 3;
}

- Show the output of the previous code using the

comparison x < 0 instead of x > 0?
 Programmer’s Toolbox
• Variables and their basic variable types
• Assignment statement

• Expressions and their evaluation

• Variable type compatibilities

• If-else statement

• Simple loops

Session 2 70