Introduction to programming-1

Beginning Concepts for Problem

Solving in C++:

variables, data types, operators, and

formatted IO
Algorithms and flowcharts
 Learning Objectives
List and explain the basic kinds of data
■ Distinguish between variables and constants
■ Declare integer, floating point, and character variables
■ List the basic data types used in C++
■ Identify and explain commonly used operators in C++
■ Use C++ operators correctly according to their placement in the
hierarchy chart
■ Set up and evaluate expressions and equations using variables,
constants, operators, and hierarchy of operations

3
 Character Set
• Set of characters used in the language
• Alphabets
• A to Z and a to z
• Digits 0 to 9
• Special Ch , : . “ ! + - * / ? # $ etc

4
ASCII Table

Back
 Escape Sequences (partial list)
Escape
Represents
Sequence
\a Bell (alert)
\b Backspace
\f Formfeed
\n New line
\r Carriage return
\t Horizontal tab
\v Vertical tab
\' Single quotation mark
\“ Double quotation mark
\\ Backslash
\? Literal question mark

6
 Types of Data (simplified view)
• The basic kinds of data that we will mostly use:
– Numeric
• Integers:
• Real (floating point) numbers:
– Character (are enclosed by single quotes in C)
• All letters, numbers, and special symbols
– Ex. ‘A’, ‘+’, ‘5’
– String (are enclosed by double quotes in C)
• Are combinations of more than one character
– Ex. “programming”, “ME 30”
– Logical (also called ‘Boolean’ named after George Boole an English mathematician
from the early 1800’s)
• True or False (1 or 0)

7
 Write the Type of Data for each value
I-Integer, F-floating point, S-String, C-character
Data Type
1. 17
2. “George”
3. 2.35
4. 0.0023
5. -25
6. ‘m’
7. 4.32E-6
8. “185.3”
9. 0
10. 1
8
Figure 2-6Standard data types
 Constants and Variables
• Constant
– A data element that never changes in your program
• 5, 62.37, 4.219E-6, “record_string”, ‘$’
• i = j + 7; /* which one is the constant? */
• first_letter = ‘a’; /* which one is the constant? */

• Variable
– A data element that can take on different values
• Its name represents a location (address) in memory
– i = j + 7; /* which are variables? */
– second_letter = ‘b’;/* which is the variable? */
• Values are ‘assigned’ using a single equal sign ( = )
– Read the statement: i = j + 7;

NOTE!! Variables in C++ must be ‘declared’ before they can be used!

10
 Declaring Variables and Data Types

• Variables must be declared before they can be used

– Gives info to the compiler about:
• How many bytes of memory to set aside
• How to interpret the bytes (data)
– Example:
int my_var; /* an integer variable my_var */
float sensor1; /* a float variable sensor1 */
char Letter01_a; /* a char variable Letter01_a */
• Two parts are needed in the declaration:
– Data type designator (e.g., int), (note, a ‘reserved word’)
– Identifier (i.e., a name: my_var), must be a valid identifier

11
 Data Types and Memory
• Recall that declaring a variable
– sets aside memory and
– indicates the type of data that will be stored
• Considerations in declarations
– What kind of data will you be working with?
• Just whole numbers? Fractions? Characters?
– Is speed important?
• Integer operations are fastest
– How much memory is available?
• Important for embedded systems and microcontrollers
– What is the range of the data?
• From 0 to n, or from –n to +n, etc.
– What kind of precision do you need?
• Precision number of decimal places

12
Hierarchy of
Data Types Data Types

void Scalar Types Aggregate Types

arrays structs unions

Pointers Arithmetic Types enum

Integral Types Floating Types

float
unsigned signed
double
long double
char
short
int
long
long long
13
 Memory Allocation for Arithmetic Data Types

Size (bytes) Range of Values

Name (alternate) Description AVR GCC MSVC++ AVR GCC MSVC++

Signed: -128 to 127 (-2(8-1) to 2(8-1)-1) Signed: -128 to 127

char Character or small integer 1 1 Unsigned: 0 to 255 (0 to 28-1) Unsigned: 0 to 255

Signed: -32768 to 32767 Signed: -32,768 to 32,767

short int (short) Short integer 2 2 Unsigned: 0 to 65535 Unsigned: 0 to 65535

Signed: -2,147,483,648 to
Signed: -32768 to 32767 2,147,483,647
int Integer 2 4 Unsigned: 0 to 65535 Unsigned: 0 to 4,294,967,295

Signed: -2,147,483,648 to Signed: -2,147,483,648 to

2,147,483,647 2,147,483,647
long int (long) Long integer 4 4 Unsigned: 0 to 4,294,967,295 Unsigned: 0 to 4,294,967,295

Signed: ≈ -9.2E+18 to ≈ 9.2E+18 Signed: ≈ -9.2E+18 to ≈ 9.2E+18

long long int (long long) Really long integer 8 8 Unsigned: 0 to ≈ 1.8E+19 Unsigned: 0 to ≈ 1.8E+19

≈ ±1E ± 38 (7 decimal digits of ≈ ±1E ± 38 (7 decimal digits of

float 'Single-precision' floating point number 4 4 precision) precision)

≈ ±1E ± 38 (7 decimal digits of ≈ ±1E ±308 (15 decimal digits of

double 'Double-precision' floating point number 4 8 precision) precision)

Long double-precision floating point ≈ ±1E ±308 (15 decimal digits of

long double number 8 precision)

14
2.6

Constants
Note:

A character constant is enclosed in

single quotes.
Note:

Use single quotes for character

constants.
Use double quotes for string constants.
Note:

The only bool types constants are true,

printed as 1, and false, printed as 0.
Figure 2-10 Some strings

"" // A null string

"h"
"Hello World!\n"
"HOW ARE YOU?"
"Good Morning!"
"'Good' Morning!" // 'Good' Morning
"\"Good\" Morning!" // "Good" Morning
Figure 2-11 Null characters and null strings

'\0' Null character

"" Empty string

Operators
 Arithmetic Operations
Name Symbol Example Result

Exponentiation ^ 4^2 16

Multiplication * 16*2 32

Division / 16/2 8

Addition + 16+2 18

Subtraction - 16-2 14
 Operator Hierarchy
1. Parenthesis
2. Exponentiation
3. Multiplication/Division
4. Addition/Subtraction
 Hierarchy of Operations Example
3 * (6 + 2) / 12 – (7 – 5) ^ 2 * 3 ( ) first
= 3 * 8 / 12 – 2 ^ 2 * 3 ^ next
= 3 * 8 / 12 – 4 * 3 Mult/Div (L to R)
= 24 / 12 – 4 * 3 Mult/Div (L to R)
= 2 – 12 Add/Subtr
= -10
 Operators
• Operator: a symbol (or combination of symbols) used to
combine variables and constants to produce a value
(Overland, B. (1995) C in plain English, MIS Press, New York.)

– The variables and constants that get combined are

called ‘operands’
– How the combining is carried out depends on the
precedence and associativity of the operator
– Example – identify the operator(s), operands, and
results on each line:
int i, j = 3;
i = j + 7;

25
 Operator Precedence
and Associativity
• All operators have the properties
of precedence and associativity.
• Precedence has to do with which
operations take priority in
groupings of operands around
adjacent operators
• Associativity has to do with which
operations take priority when the
operators in an expression have
the same precedence
• Use parentheses () to specify a
particular grouping order and to
make expressions more readable

26
27
 Operator Practice
• Identify the operators, operands, and results
on each line
int i, count, mult, mult2=1, total_sum;
float total_percentage;
i = 1;
mult = total_sum = i;
count = i + 1;
count = count + 1;
total_percentage = total_sum / 100; /* a little tricky! */
mult1 = count * 17.23;
count += 1;
mult2 *= 2;

28
 Arithmetic with Mixed Data Types
• Fundamentally, the computer is not able to
arithmetically combine data of different types
– Arithmetic with integers integer results
• int div_int = 8 / 5; /* what is div_int? */
– Arithmetic with floating point data floating point results
• float div_flt = 8.0 / 5.0; /* what is div_flt? */
– Arithmetic with integers and floating point values in the
same expressions ??
• int div_int = 8.0 / 5; /* what is div_int? */
• float div_flt = 8.0 / 5; /* what is div_flt? */

29
 Implicit Type Casting
Higher
long double
• In binary operations (e.g., +, -, /, etc.) double
with operands of mixed data types, the float
resultant data type will take the higher unsigned long long
order data type of the two operands1 long long

unsigned long

long

unsigned int

int

unsigned short

short

unsigned char

char
Lower

1
Cheng, Harry H. (2010). C for Engineers and Scientists: An Interpretive Approach, McGraw-Hill, New York. 30
 Expressions and Statements
• Expression
– Any combination of operators, numbers, and names that
evaluates to a single value
• 5
• j = 17
• j = i = 10
• i+j
• Statement
– A chunk of code that does something (executes)
• Terminating an expression with a semicolon (;) turns it into a
statement
– We will cover other statements later

31
 Practice - operator precedence
■ On paper, determine output of:

int i, j = 3;
i = j + 7;
i = j / 12 + 5;
int k = (j + i * 3);
printf(“%d, %d, %d”, i, j, k);

◻ Output:
32
 Practice - operator precedence solution
■ Program Trace:

int i, j = 3; /* j = 3 */
i = j + 7; /* i = 3+7 = 10 */
i = j / 12 + 5; /* i = (3/12)+5 = 9 */
int k = (j + i * 3); /* k=3+27=30 */
printf(“%d, %d, %d”, i, j, k);

◻ Output: 9, 3, 30

33
 Reserved Words in C++
You may not use these as variable names

auto double int struct

break else long switch
case enum register typedef
char extern return union
const float short unsigned
continue for signed void
default goto sizeof volatile
do if static while
Back 34
 Example
START
Step 1: Input M1,M2,M3,M4
Step 2: GRADE ← (M1+M2+M3+M4)/4
Input
M1,M2,M3,M4
Step 3: if (GRADE <50) then
Print “FAIL”
else
GRADE←(M1+M2+M3+M4)/4
Print “PASS”
endif
N IS Y
GRADE<50

PRINT PRINT
“PASS” “FAIL”

STOP
 Example 2
• Write an algorithm and draw a flowchart to
convert the length in feet to centimeter.
Pseudocode:
• Input the length in feet (Lft)
• Calculate the length in cm (Lcm) by multiplying
LFT with 30
• Print length in cm (LCM)
 Example 2
Algorithm Flowchart

• Step 1: Input Lft START

• Step 2: Lcm = Lft x 30 Input

Lft

• Step 3: Print Lcm

Lcm =Lft x 30

Print
Lcm

STOP
 Example 3
Write an algorithm and draw a flowchart that will
read the two sides of a rectangle and calculate its
area.
Pseudocode
• Input the width (W) and Length (L) of a rectangle
• Calculate the area (A) by multiplying L with W
• Print A
 Example 3

Algorithm START

• Step 1: Input W,Length Input

W, L
• Step 2: Area = Length x W
• Step 3: Print Area A=LxW

Print
A

STOP
 Example 4
• Write an algorithm and draw a flowchart that will
calculate the roots of a quadratic equation

• Hint: d = sqrt ( ), and the roots are: x1 =

(–b + d)/2a and x2 = (–b – d)/2a
 Example 4
Pseudocode:
• Input the coefficients (a, b, c) of the quadratic
equation
• Calculate d
• Calculate x1
• Calculate x2
• Print x1 and x2
 Example 4
START

• Algorithm:
Input
• Step 1: Input a, b, c a, b, c
• Step 2: d = sqrt ( )
• Step 3: x1 = (–b + d) / (2 x a) d = sqrt(b x b – 4 x a x c)
• Step 4: x2 = (–b – d) / (2 x a)
x1 =(–b + d) / (2 x a)
• Step 5: Print x1, x2
X2 = (–b – d) / (2 x a)

Print
x1 ,x2

STOP
 1 // Fig. 1.2: fig01_02.cpp
Outline
2 // A first program in C++
Comments
3 #include <iostream.h> 1. Comments
Written between /* and */ or following a //.
4 Improve program readability and do not cause the
5 int main() computer to perform any action. 2. Load <iostream>

6 { 3. main
preprocessor directive
7 cout << "Welcome to C++!\n";
Message to the C++ preprocessor.3.1 Print "Welcome to
8 C++\n"
Lines beginning with # are preprocessor directives.
9 return 0; // indicate that program ended successfully
#include <iostream.h> tells the (return 0)
3.2 exit
10 } preprocessor
C++ to include
programs contain onethe
orcontents of the file
more functions, one of
<iostream>, which
which must be main includes input/output
Program
operations (such as printing to the screen).Output
Welcome to C++! Parenthesis are used to indicate a function
int means
Prints the string of characters that main
contained "returns"
between the an integer value.
quotation marks. More in Chapter 3.
return is a way to exit a function
from a function. A left brace begins the body
The entire line, including cout, the{ << operator, theof every function
return 0, in this case, means
string that
"Welcome toand a right brace
C++!\n" } ends
and the it.
semicolon
the program terminated
(;),normally.
is called a statement.

All statements must end with a semicolon.

43
© 2000 Prentice Hall, Inc. All rights reserved.