c++programming

Introduction to Programming in C++

Seventh Edition

Chapter 1:

An Introduction to Programming

Chapter Objectives

• Define the terminology used in programming

• Explain the tasks performed by a programmer

• Understand the employment opportunities for programmers and software engineers

• Explain the history of programming languages

• Explain the sequence, selection, and repetition structures

• Write simple algorithms using the sequence, selection, and repetition structures

An Introduction to Programming with C++, Seventh Edition 2

Programming a Computer

It is important to understand the relationship between the terms programs, programmers, and programming languages.

Programs - The directions that humans give to computers

Programmers - The people who create these directions

Programming Languages - Special languages used by programmers to communicate directions to a computer

The Programmer’s Job

• Programmers help solve computer problems

• Employee or freelance

• Typical steps involved

– Meet with user to determine problem

– Convert the problem into a program

– Test the program

– Provide user manual

What Traits Should a Software Developer

Possess?

• Analytical skills

• Communication skills

• Creativity

• Customer-service skills

• Detail oriented

• Problem-solving skills

• Teamwork

• Technical skills

Employment Opportunities

• Computer software engineer: designs an appropriate solution to a user’s problem

• Computer programmer: codes a computer solution

• Coding is the process of translating a computer solution into a language a computer can understand

• Some positions call for both engineering and programming

A Brief History of Programming Languages

There are many different types of programming languages. This chapter will discuss:

•Machine languages

•Assembly languages

•High-level procedure-oriented languages

•High-level object-oriented languages

Machine Languages

• The first programmers had to write the program instructions using only combinations of 0s and 1s

– Example: 0000 0101 1100 0000

• Instructions written in 0s and 1s are called machine language or machine code

• Each type of machine has its own language

• Machine languages are the only way to communicate directly with the computer

• Programming in machine language: tedious and error-prone; requires highly trained programmers

Assembly Languages

• Assembly languages made writing code simpler than using only 0s and 1s

• Mnemonics – symbols used to represent the actual machine language instructions Example: 00000101 vs. BALR

• Assembly programs require an assembler to convert instructions into machine code

• Easier to write programs in assembly language

– But still tedious and requires highly trained programmers

High-Level Languages

• High-level languages allow programmers to use English-like instructions Example: taxAmount = total * taxRate

• Each high-level language instruction is equivalent to more than one machine language instruction

• Compilers translate high-level instructions into 0s and 1s (machine language)

• Interpreters translate the program line by line as the program is running

High-Level Languages (cont.)

• When writing a procedure-oriented program, the programmer concentrates on the major tasks that the program needs to perform

– Examples: COBOL, BASIC, C

• An object-oriented program requires the programmer to focus on the objects that the program can use to accomplish its goal

– Examples: C++, Visual Basic, Java, C#

• Object-oriented programs allow for an object to be created that can be reused in more than one program

Control Structures

All computer programs are written using one or more of three basic control structures: sequence, repetition, and selection. Another term used for control structures are logic structures, because they control the logic flow of the program. While in every program that is written the sequence structure will be used, in most all programs all three control structures will be used.

The Sequence Structure

• The sequence structure directs the computer to process the program instructions, one after another, in the order in which they are listed in the program

• An algorithm is a finite number of step-by-step instructions that accomplish a task

• Example: steps to pump gas at a self-service pump

The Sequence Structure (cont.)

Figure 1-1 An example of the sequence structure

The Selection Structure

• The selection structure directs the computer to make a decision (evaluate a condition), and then take an appropriate action based upon that decision

• The selection structure allows the programmer to evaluate data, therefore properly controlling the logic flow of the program

• Another name for the selection structure is the decision structure

• Example: stopping or going at a signal light

The Selection Structure (cont.)

Figure 1-2 An example of the selection structure

The Selection Structure (cont.)

Figure 1-3 Another example of the selection structure

The Repetition Structure

• The repetition structure, commonly called iteration or looping, directs the computer to repeat one or more program instructions until some condition is met

• This condition may be checked at the beginning or end of the set of instructions to be processed dependent upon the language being used

• The repetition structure allows the programmer to repeatedly process a set of instructions, while only typing them in once

The Repetition Structure (cont.)

Figure 1-4 Original algorithm and modified

algorithm showing the repetition structure

• What could you do if you do not know precisely how many steps separate Harold from the boxes as described on the bottom of page 9?

Figure 1-5 Algorithm showing the modified

condition in the repetition structure

Summary

• Programs are step-by-step instructions that tell a computer how to perform a task

• Programmers use programming languages to communicate with the computer

• First programming languages were machine language using 0s and 1s

• Assembly languages followed, using mnemonics

• High-level languages can be used to created procedure-oriented or object-oriented programs

Summary (cont.)

• An algorithm is a finite number of step-by-step instructions that accomplish a task

• Algorithms utilize three basic control structures: sequence, selection, and repetition

• The sequence structure directs the computer to process the program instructions, one after another, in the order in which they are listed

• The selection structure directs the computer to make a decision (evaluate a condition), and then take an appropriate action based upon that decision

Summary (cont.)

• The repetition structure, commonly called iteration or looping, directs the computer to repeat one or more program instructions until some condition is met

• The sequence structure is used in all programs

• Most programs also contain both the selection and repetition structures

Lab 1-1: Stop and Analyze

• A local business employs five salespeople and pays a 3% bonus on a salesperson’s sales

• Your task is to create a program that calculates the amount of each salesperson’s bonus

• The program should print each salesperson’s name and bonus amount

Lab 1-2: Plan and Create

• Using only the instructions shown below, create an algorithm that shows the steps an instructor takes when grading a test that contains 25 questions

Lab 1-3: Modify

• Modify the algorithm shown in Lab 1-1 so that it gives a 3.5% bonus to salespeople selling more than $2,000

• All other salespeople should receive a 3% bonus

Seventh Edition

Chapter 2:

Beginning the Problem-Solving Process

• Explain the problem-solving process used to create a computer program

• Analyze a problem

• Complete an IPO chart

• Plan an algorithm using pseudocode and flowcharts

• Desk-check an algorithm

Chapter Objectives

2 An Introduction to Programming with C++, Seventh Edition

• People solve hundreds of simple problems every day without thinking about how they do it

• Understanding the thought process involved can help in solving more complex problems

• You can also use a similar process to design a computer solution to a problem (computer program)

Problem Solving

• First step in solving a problem: analyze it

– Example: paying and mailing a bill

• Next, you plan, review, implement, and evaluate the solution

• After this, it may be necessary to modify the solution

Solving Everyday Problems

Solving Everyday Problems (cont’d.)

Figure 2-1 Summary of the analysis and planning steps for

the bill paying problem

Solving Everyday Problems (cont’d.)

Figure 2-2 Modified algorithm for the bill paying problem

• A similar process to everyday problem solving is used to create computer programs

• A computer program is a solution implemented on a computer

• There are six steps to creating a computer solution to a problem

Creating Computer Solutions to Problems

(cont’d.)

Figure 2-3 How to create a computer solution to a problem

• It is essential to understand a problem before creating a solution to it

• Analyze a problem to:

– Determine the goal of solving it (Output)

– Determine the items needed to achieve that goal (Input)

• Always search first for the output

Step 1−Analyzing the Problem

Step 1−Analyzing the Problem (cont’d.)

Figure 2-4 Problem specification for Treyson Mobley

• Some programmers use an IPO chart to organize and summarize the results of a problem analysis

– IPO: Input, processing, and output

Step 1−Analyzing the Problem (cont’d.)

Figure 2-5 Partially completed IPO chart

showing the input and output items

• Several readings of the problem may be necessary to fully understand the problem

• Cross out irrelevant information in the problem description

Hints for Analyzing Problems

Figure 2-6 Problem specification with

unimportant information crossed out

• Some problem specifications contain incomplete information

Hints for Analyzing Problems (cont’d.)

Figure 2-7 Problem specification that does

not contain enough information

• Distinguish between information that is missing and information that is implied

Hints for Analyzing Problems (cont’d.)

Figure 2-8 Problem specification in

which the input is not explicitly stated

• Algorithm: set of instructions that will transform the problem’s input into its output

– Record in the Processing column of the IPO chart

– Can be written as pseudocode or a flowchart

• Pseudocode: tool programmers use to help plan an algorithm

– Short English statements

– Not standardized

– Not understandable by a computer

Step 2−Planning the Algorithm

Step 2−Planning the Algorithm (cont’d.)

Figure 2-9 Problem specification and IPO

chart for the Treyson Mobley problem

• Flowcharts are also used to plan an algorithm

– Use standardized symbols

– Symbols connected with flowlines

– Oval: start/stop symbol

• Represents beginning and end of algorithm

– Rectangle: process symbol

• Represents tasks such as calculations

– Parallelogram: input/output symbol

• Represents I/O tasks

Figure 2-10 Figure 2-9’s algorithm in flowchart form

• A problem can have more than one solution

Figure 2-11 A different solution to the

Treyson Mobley problem (pseudocode)

• Processing item: an intermediate value (neither input nor output) the algorithm uses to transform input into output

Figure 2-11 A different solution to the Treyson

Mobley problem (flowchart)

Step 3−Desk-Checking the Algorithm

• Desk-checking an algorithm verifies that it is correct

– Refers to checking an algorithm by hand, rather than with a computer

– Also called hand-tracing

• Choose sample data and manually compute the expected output value

• Creating a desk-check table can be helpful

(cont’d.)

Figure 2-12 Manual tip calculation for the first desk-check

(cont’d.)

Figure 2-13 Treyson Mobley solution and

partially completed desk-check table

(cont’d.)

Figure 2-14 Input values entered in the desk-check table

Figure 2-15 Processing item’s value

entered in the desk-check table

Figure 2-16 Output value entered in the desk-check table

(cont’d.)

Figure 2-17 Manual tip calculation for

the second desk-check

Figure 2-19 Value of the second desk-check’s

processing item entered in the desk-check table

Figure 2-20 Value of the second desk-check’s

output item entered in the desk-check table

Figure 2-18 Second set of input values

entered in the desk-check table

(cont’d.)

• Valid data: data that the algorithm is expecting the user to enter

• Invalid data: data that the algorithm is not expecting the user to enter

• You should test an algorithm with invalid data

– Users may make mistakes when entering data

(cont’d.)

The Gas Mileage Problem

Figure 2-21 Problem specification for the gas mileage problem

The Gas Mileage Problem (cont’d.)

• Plan the algorithm with an IPO chart

Figure 2-22 IPO chart for the gas mileage problem

• Then desk-check the algorithm

The Gas Mileage Problem (cont’d.)

Figure 2-23 Desk-check table for the gas mileage problem

• Problem solving typically involves analyzing the problem and then planning, reviewing, implementing, evaluating, and modifying (if necessary) the solution

• Programmers use tools (IPO charts, pseudocode, flowcharts) to help them analyze problems and develop algorithms

• The first step in problem solving is to analyze the problem

– First determine the output and then the input

Summary

• The second step is to plan the algorithm

– Write the steps that will transform the input into the output

– Most algorithms begin with entering input data, then processing the data, then displaying the output

• The third step is to desk-check the algorithm

– Choose sample data and manually compute the expected output

– Create a desk-check table to fill in values step by step

Summary (cont’d.)

• Aiden Nelinski is paid every Friday and will receive either a 2.0% or 2.5% raise next week

• He wants a program that calculates and displays the amount of his new weekly pay

Figure 2-26 IPO chart for Lab 2-1

• Create an algorithm for the manager of the Lakeview Hotel

Figure 2-30 Completed IPO chart for Lab 2-2

• Each guest of the Lakeview Hotel pays an entertainment tax, which is a percentage of the room charge only

• Modify the IPO chart in Figure 2-30

• Desk-check the algorithm twice using the given values

Lab 2-3: Modify

• An algorithm is given to calculate and display an annual property tax

• Desk-check the algorithm three times using the given values

Lab 2-4: Desk-Check

• An algorithm is given to calculate and display the average of three numbers but is incorrect

• Find and correct the errors in the algorithm

Lab 2-5: Debug

Figure 2-42 Corrected algorithm for Lab 2-5

Seventh Edition

Chapter 3:

Variables and Constants

• Distinguish among a variable, a named constant, and a literal constant

• Explain how data is stored in memory

• Select an appropriate name, data type, and initial value for a memory location

• Declare a memory location in C++

An Introduction to Programming with C++, Seventh Edition

Chapter Objectives

• After Step 3, programmer has an algorithm and has desk-checked it

• The fourth step in the process is coding the algorithm into a program

• The step begins by assigning a descriptive name, data type, and (optionally) initial value to each unique input, processing, and output item in the IPO chart

• These are used to store the item in the computer’s internal memory

Beginning Step 4 in the Problem-Solving

Process

• Computer’s internal memory is composed of memory locations, each with a unique numeric address

• Similar to collection of storage bins

• Each address can store one item at a time

• Address can contain numbers, text, or program instructions

• To use a memory location, programmer must reserve the address, called declaring

Internal Memory

• Declaring a memory location is done with an instruction that assigns a name, data type, and (optional) initial value

• The name allows the programmer to refer to the memory location elsewhere in the program using a descriptive word, rather than the numeric address

• The data type indicates what type of information the address will store (e.g., number or text)

Internal Memory (cont’d.)

• Two types of memory locations can be declared: variables and named constants

• Variables are memory locations whose values can change during runtime (when the program is running)

• Most memory locations are variables

• Named constants are memory locations whose values cannot change during program execution

Figure 3-1 Illustration of storage bins

• Name (identifier) assigned to a memory location should be descriptive

• Should help the programmer/other programmers remember/understand the memory location’s purpose

• Should be as short as possible while still being descriptive (especially if referenced often)

• Short names are easier to read and result in more concise code

Selecting a Name for a Memory Location

• Rules for memory location names in C++

– Name must begin with a letter and contain only letters, numbers, and the underscore character

– No punctuation marks, spaces, or other special characters (such as $ or %) are allowed

– Cannot be a keyword (word that has special meaning in C++)

– Names are case sensitive

• Example: discount is different from DISCOUNT and from Discount

(cont’d.)

• Most programmers use uppercase letters for named constants and lowercase for variables

– Example: PI (constant), radius (variable)

• If constants contain more than one word, separate words with underscores

– Example: TAX_RATE

• If variables contain more than one word, capitalize the first letter of each word after the first (called camel case)

– Example: adjustedGrossIncome

(cont’d.)

Figure 3-2 How to name a memory location in C++

(cont’d.)

Revisiting the Treyson Mobley Problem

Figure 3-3 Problem specification, IPO chart,

and desk-check table from Chapter 2

• IPO chart contains five input, processing, and output items

• Five memory locations are needed to store the values of the items

• Memory locations will be variables since their values will change during runtime

(cont’d.)

Figure 3-4 Names of the variables for the Treyson Mobley problem

• Memory locations come in different types and sizes

• Type and size you choose depends on the item you want to store

• A memory location will only accept an item that matches its data type

• Data type of a memory location is determined by the programmer when declaring the location

Selecting a Data Type for a Memory

Location

• Fundamental data types are basic data types built into C++

– Also called primitive or built-in data types

– Include short, int, float, double, bool, and char

• bool data type stores Boolean values (true and false)

• short and int types store integers (numbers without a decimal place)

– Differences are range of values and memory used (int

has the greater of both)

Location (cont’d.)

• float and double types store real numbers (numbers with a decimal place)

– Differences are range of values, precision, and memory used (double has the greater of each)

• char type stores characters (letter, symbol, or number that will not be used in a calculation)

– Only one character stored at a time

• string data type is a user-defined data type (defined with a class, or group of instructions)

– Can store zero or more characters

Figure 3-5 Most commonly used data types in C++

• 1 byte = 8 bits

• 1 kilobyte (K / Kb) = 2^10 bytes = 1,024 bytes

• 1 megabyte (M / MB) = 2^20 bytes = 1,048,576 bytes

• 1 gigabyte (G / GB) = 2^30 bytes = 1,073,741,824 bytes

• 1 terabyte (T / TB) = 2^40 bytes = 1,099,511,627,776 bytes

• 1 petabyte (P / PB) = 2^50 bytes = 1,125,899,906,842,624 bytes

• 1 exabyte (E / EB) = 2^60 bytes = 1,152,921,504,606,846,976 bytes

Figure 3-6 Data type assigned to each

variable for the Treyson Mobley problem

• Numbers represented in internal memory using binary (base 2) number system (two digits, 0 and 1)

• We are used to the decimal (base 10) number system (ten digits, 0 through 9)

• Character data is stored using ASCII codes

– Eight-bit codes (bit = binary digit, 0 or 1)

– Upper- and lowercase versions of letters have distinct codes

• Computer distinguishes between numbers and ASCII codes based on data type

How Data Is Stored in Internal Memory

(cont’d.)

Figure 3-7 How to use the decimal (base 10) number system

(cont’d.)

Figure 3-8 How to use the binary (base 2) number system

Figure 3-9 Partial ASCII chart

(cont’d.)

• Setting an initial value for a variable or named constant is called initializing

• Required for constants; recommended for variables

• Memory locations are usually initialized with a literal constant (item of data that can appear in a program instruction and be stored in memory)

• Data type of literal constant should match data type of memory location it is assigned to

Selecting an Initial Value for a Memory

Location

• Numeric literal constants initialize short, int, float, and double data types

– Can contain digits 0 through 9, +, -, ., and e or E (for scientific notation)

• Character literal constants initialize char data types

– Consist of one character in single quotation marks

• String literal constants initialize string data types

– Zero or more characters enclosed in double quotation marks

– Empty string (“”) is a valid string literal constant

• Before assigning initial value to a memory location, computer checks that value’s data type matches location’s data type

• If they don’t match, computer performs implicit type conversion to match them

– If initial value is converted to type that holds larger numbers, value is promoted

– If initial value is converted to type that only holds smaller numbers, value is demoted

• Promoting will not usually have adverse effects, but demoting can (information is lost)

• Important to initialize memory locations with values of the same data type

• Named constants should be initialized with the value they will hold for the duration of the program

• Variables whose initial values are not known should still be initialized

– short and int types usually initialized to 0

– float and double types usually initialized to 0.0

– string types usually initialized to empty string (“”)

– bool types initialized to either true or false

Figure 3-10 Initial values for the variables

in the Treyson Mobley problem

• Variables and named constants are declared using a statement (C++ instruction)

• A statement that declares a variable causes the computer to set aside a memory location with the given name, data type, and initial value

• Statements must follow correct syntax (rules of a programming language)

• In C++, all statements must end with a semicolon

Declaring a Memory Location

• When declaring variables, a data type and name must be provided

• Syntax for declaring a variable in C++ – dataType variableName [= initialValue];

• After variable is declared, you use its name to refer to it later in the program

• Initial value is optional but recommended

• If variable is not initialized, it contains the previous value of that memory location, which may be the wrong type (called a garbage value)

Declaring a Memory Location (cont’d.)

• Syntax for declaring a named constant in C++

– const dataType constantName = value;

• The const keyword indicates that the memory location is a named constant (value cannot be changed during runtime)

• Initial value required for constants, unlike variables

• As with variables, after declaring a constant, you can use its name to refer to it later in the program

• Several advantages to using named constants when appropriate

– Make program more self-documenting (meaningful words in place of numbers)

– Value cannot be inadvertently changed during runtime

– Typing a name is less error-prone than a long number

– Mistyping a constant’s name will trigger a compiler error; mistyping a number will not

– If the constant needs to be changed when modifying the program, it only needs to be changed in one place

Figure 3-11 How to declare a variable in C++

Figure 3-12 C++ declaration statements for the

variables in the Treyson Mobley problem

Figure 3-13 How to declare a named constant in C++

• Fourth step in problem-solving process is coding the algorithm

• Memory location is declared for each input, processing, and output item in IPO chart

• Numeric data is stored in computer’s internal memory using binary number system

• Memory locations store one item at a time

• Memory location’s data type determines how a value is stored and interpreted when retrieved

Summary

• Two types of memory locations: variables and named constants

• Memory locations are declared using a statement that assigns a name, data type, and initial value

• Initial value required for named constants but optional for variables (though recommended)

• Most memory locations initialized with literal constants, except bool (initialized with keywords true or false)

Summary (cont’d.)

• Data type of literal constant assigned to memory location should be same as memory location’s type

• If types don’t match, implicit type conversion is used to either promote or demote so they match

• Promoting doesn’t usually cause problems, but demoting can

• Syntax for declaring variables

– dataType variableName [= initialValue];

• Syntax for declaring named constants

– const dataType constantName = value;

Summary (cont’d.)

Figure 3-14 Problem specification, IPO chart,

and desk-check table for Lab 3-1

Figure 3-15 Problem specification for Lab 3-2

• Modify the IPO chart in Figure 3-17 so that it includes the radius squared as a processing item

Lab 3-3: Modify

Figure 3-17 Completed IPO chart for Lab 3-2

• Using the IPO chart modified in Lab 3-3, modify the manual calculations and desk-check tables shown in Figures 3-18 and 3-19

Lab 3-4: Desk-Check

Figure 3-18 Manual area calculations for the two desk-checks

Figure 3-19 Completed desk-check table for Lab 3-2

• Correct the C++ instructions shown in Figure 3-21

– The memory locations will store real numbers

• Find and correct the errors in the algorithm

Lab 3-5: Debug

Figure 3-21 IPO chart information and C++ instructions for Lab 3-5

Seventh Edition

Chapter 4:

Completing the Problem-Solving Process

• Get numeric and character data from the keyboard

• Display information on the computer screen

• Write arithmetic expressions

• Type cast a value

• Write an assignment statement

• Code the algorithm into a program

• Desk-check a program

• Evaluate and modify a program

Objectives

• The fourth step in the problem-solving process is to code algorithm into a program

• Begin by declaring a memory location for each input, processing, and output value in IPO chart

• Optionally initialize each value (highly preferred)

• Next, you code the instructions for the algorithm

Finishing Step 4 in the Problem-Solving

Process

Figure 4-1 Problem specification, IPO chart

information, and variable declaration

Finishing Step 4 in the Problem-Solving

Process (cont’d.)

• C++ uses stream objects to perform input/output operations

• A stream is a sequence of characters

• The cin object is used to obtain information from the keyboard (program pauses while user enters data)

• The extraction operator (>>) takes information out of cin object and stores it in internal memory

– Syntax: cin >> variableName;

Getting Data from the Keyboard

Getting Data from the Keyboard (cont’d.)

Figure 4-2 Relationship among the keyboard, cin object,

extraction operator, and internal memory

Figure 4-3 How to use cin and >> to

get numeric or character data

Figure 4-4 Input statements for

the Treyson Mobley problem

• You use a prompt (message) to let the user know what data is to be entered

• The cout object is used with the insertion operator (<<) to display information on the screen

• Information can be any combination of literal constants, named constants, and variables

• Multiple items can be printed in the same statement

– Syntax: cout << item1 [<< item2 << itemN];

– Part in brackets is optional

Displaying Messages on the Computer

Screen

• A stream manipulator is used to manipulate (manage) the characters in an input or output string

• endl is a stream manipulator that advances the cursor to the next line on the screen

– Equivalent to pressing the Enter key

(carriage return and line feed)

Screen (cont’d.)

Figure 4-5 How to use the cout object

Figure 4-6 Prompts and output statement

for the Treyson Mobley problem

Screen (cont’d.)

• You can evaluate arithmetic expressions in C++ using arithmetic operators

• Operators are negation (-), addition (+), subtraction (-), multiplication (*), division (/), and modulus (%)

• Negation and subtraction use the same symbol, but negation is a unary operator (one operand) and subtraction is a binary operator (two operands)

• Modulus gives remainder when dividing two integers

Arithmetic Operators in C++

• Each operator has a precedence: determines in which order operators in an expression are evaluated

• Operators with lower-precedence numbers are evaluated before higher ones

• Parentheses have lowest-precedence number, so they can be used to override precedence order

• Operators with the same precedence number are evaluated from left to right

Arithmetic Operators in C++ (cont’d.)

Figure 4-7 Standard arithmetic operators and their order of precedence

Figure 4-8 Expressions containing more than one

operator having the same precedence

• Recall that the compiler will implicitly promote or demote data types to match when possible

• Sometimes it is necessary to explicitly cast from one data type into another

– Example: dividing two integers gives the result of integer division (no remainder), but you would really like a double result

– If one or both of the integers is a literal, you can cast it to a double by adding .0 to the end of it

– If both are variables, you must use the static_cast operator

Type Conversions in Arithmetic

Expressions

Figure 4-9 Examples of expressions that

require implicit type conversions

Type Conversions in Arithmetic

Expressions (cont’d.)

• Used to explicitly convert data from one data type to another

• Called an explicit type conversion or type cast

• Syntax: static_cast<dataType>(data)

– data can be a literal constant, named constant, or variable

– dataType is the data type to which you want the data converted

The static_cast Operator

Figure 4-10 How to use the static_cast operator

The static_cast Operator (cont’d.)

Figure 4-10 How to use the static_cast operator (cont’d.)

The static_cast Operator (cont’d.)

• You use an assignment statement to assign a value to a variable while a program is running

• Syntax: variableName = expression

– The = symbol is the assignment operator

• Tells computer to evaluate expression on right side of assignment operator and store result in variable on left side of the operator

– expression can include one or more literal constants, named constants, variables, or arithmetic operators

Assignment Statements

• Data type of expression in an assignment statement must match data type of the variable

• If they don’t match, compiler will use implicit type casting to get them to match

– Doesn’t always produce correct result

– Better to explicitly cast to correct data type yourself

• Remember:

– Declaration statement creates a new variable

– Assignment statement assigns a new value to an existing variable

Assignment Statements (cont’d.)

Figure 4-11 How to write an assignment statement

Figure 4-11 How to write an assignment statement (cont’d.)

Figure 4-12 Calculation statements

for the Treyson Mobley problem

• Allow you to abbreviate assignment statements that contain an arithmetic operator

• Statement must be of the form variableName = variableName arithmeticOperator value

• Abbreviated as variableName arithmeticOperator = value

– Example: price = price*1.05; can be abbreviated as price *= 1.05;

• Most common operators are += , -= , *= , /= , and %=

Arithmetic Assignment Operators

Figure 4-13 How to use an arithmetic assignment operator

Arithmetic Assignment Operators (cont’d)

• Fifth step is to desk-check the program to make sure instructions were translated correctly

• You should desk-check the program using sample data used to desk-check the algorithm

• Results of both desk-checks should be the same

• First, place names of the declared memory locations in a new desk-check table along with each memory location’s initial value

• Next, desk-check remaining C++ instructions in order, recording any changes made to the variables

Step 5–Desk-Check the Program

Step 5–Desk-Check the Program (cont’d.)

Figure 4-15 Variable names and initial values entered in the

program’s desk-check table

Figure 4-14 Algorithm’s desk-check table from Chapter 2

Figure 4-16 Input values entered in the program’s desk-check table

Figure 4-17 Desk-check table showing the result of the

total bill without liquor charge calculation

Figure 4-18 Desk-check table showing the result of the tip calculation

Figure 4-19 Program’s desk-check table showing the

results of the second desk-check

• Final step in the problem-solving process

• You evaluate a program by running the program on the computer and entering the sample data used when desk-checking the program

• If evaluation reveals errors (known as bugs), they must be fixed

• Process of locating and fixing errors is called debugging

• Two types of bugs: syntax errors and logic errors

Step 6–Evaluate and Modify the Program

• Syntax errors result from breaking programming language’s rules; cause compiler errors

• Logic errors don’t cause compiler errors; can be hard to identify

– Example: entering instructions in the wrong order

• Need a text editor to enter C++ instructions

• Instructions are called source code and are saved in source files with extension .cpp

• Need a compiler to translate source code into machine code (also called object code)

(cont’d.)

• Compiler saves object code in object files with extension .obj

• Linker combines .obj files with other machine code necessary to run the program and produces an executable file with extension .exe

• An IDE (integrated development environment) is a development tool that contains both an editor and compiler

• A command-line compiler contains only the compiler and requires a separate editor to enter source code

(cont’d.)

Figure 4-20 Process by which source code

is translated into executable code

• A comment is a form of internal documentation; written by placing // in front of the comment text

– Ignored by the compiler

– Considered good programming practice; makes code more readable

• A #include directive allows you to merge the source code in one file with that in another file

• The #include <iostream> is required when using the cin or cout stream objects

– Not a statement, so no semicolon needed at the end

(cont’d.)

• A using directive tells the compiler where in internal memory it can find definitions of C++ keywords and classes like double or string

• The using namespace std; directive indicates that the definitions of the standard C++ keywords and classes are located in the std (standard) namespace

– Is a statement, so semicolon required at the end

• A namespace is a special area in internal memory

(cont’d.)

• A function is a block of code that performs a task

• Functions have parentheses following their name (Example: main())

• Some functions require information between the parentheses; others do not

• Every C++ program has one (and only one) main function; this is where program execution begins

• Some functions return a value, and the data type they return appears to the left of the function name

– Example: int main()

(cont’d.)

• Other functions do not return a value, and void appears to the left of the function name

• The return type, name, and parameters (information in parentheses) constitute the function header, which marks the beginning of the function

• After the function header, you enter the function’s code

• You enclose a function’s code in a set of braces ({})

• The code between the braces is called the function body

(cont’d.)

Figure 4-21 Treyson Mobley program

(cont’d.)

Figure 4-21 Treyson Mobley program (cont’d.)

(cont’d.)

Figure 4-22 Command Prompt window

• Fourth step in problem-solving process is coding the algorithm into a program

• C++ uses stream objects for standard input/output operations

• Use cin with extraction operator (>>) to get numeric or character data from the keyboard

• Use cout with insertion operator (<<) to display information on the screen

• The endl stream manipulator advances cursor to next line

Summary

• You do calculations by writing arithmetic expressions using arithmetic operators

• Each operator has a precedence: determines the order of evaluation in an expression

• Parentheses are used to override this order

• Compiler implicitly casts data types when possible, but you should explicitly cast to ensure correctness

• Use the static_cast operator to explicitly cast variables from one data type to another

Summary (cont’d.)

• An assignment statement assigns a value to a variable during runtime

• The expression on the right side of the assignment operator (=) in an assignment statement is stored in the variable on its left

• Fifth step of the problem-solving process is to desk-check the program using the same data used to desk-check the algorithm

• The sixth step is to evaluate and modify (if necessary) the program

Summary (cont’d.)

• Errors (called bugs) can either be syntax errors or logic errors

• You need a text editor and compiler to enter C++ instructions and compile them into a program

• C++ instructions are called source code and are saved in source files with the extension .cpp

• The compiler translates source code into machine code, also called object code

• A linker produces an executable file that contains all machine code necessary to run a C++ program

Summary (cont’d.)

• Programmers use comments to document a program internally

– Comments are not processed by the compiler

• The #include <filename> directive allows you to include multiple source files in a program

• The using namespace std; directive tells the compiler where definitions of standard C++ keywords and classes are in internal memory

• A namespace is a special area in the computer’s internal memory

Summary (cont’d.)

• Execution of every C++ program begins with the main() function

• The first line of a function is the function header

• The function body follows the header and is enclosed in braces

• Some functions return a data type; others return void

• Arithmetic assignment operators can be used to abbreviate certain assignment statements with arithmetic operators in them

Summary (cont’d.)

Figure 4-23 Examples for Lab 4-1

• Plan and create an algorithm that displays the total amount a student owes for a semester

• Modify the program in Lab 4-2 to account for Hoover College having courses that can be 0.5, 1, 2, or 3 semester hours

• Additionally, fee per hour is raised to $105

• Test the program twice, using 9.5 and 11 as the number of hours enrolled

Lab 4-3: Modify

• Desk-check the three lines of code shown in Figure 4-31

Lab 4-4: Desk-Check

Figure 4-31 Code for Lab 4-4

• Follow the instructions for starting C++ and opening the Lab4-5.cpp file

• If necessary, make the system(“pause”); statement a comment, and then save the program

• Run and then debug the program

Lab 4-5: Debug

Seventh Edition

Chapter 5:

The Selection Structure

• Include the selection structure in pseudocode and in a flowchart

• Code a selection structure using the if statement

• Include comparison operators in a selection structure’s condition

• Include logical operators in a selection structure’s condition

• Format numeric output

Objectives

• With only the sequence structure, all instructions are executed in order

• A selection structure is needed when a decision must be made (based on some condition) before selecting an instruction to execute

• A selection structure’s condition must be phrased as a Boolean expression (evaluates to true or false)

Making Decisions

• Single-alternative selection structure

– Set of instructions is executed only if condition evaluates to true

• Dual-alternative selection structure

– Executes different sets of instructions based on whether condition evaluates to true or false

• True path

– Instructions followed when condition evaluates to true

• False path

– Instructions followed when condition evaluates to false

Making Decisions (cont’d.)

Figure 5-1 A problem that requires

the sequence structure only

Figure 5-2 A problem that requires the sequence structure

and a single-alternative selection structure

Figure 5-3 A problem that requires the sequence

structure and a dual-alternative selection structure

• Recall from Chapter 2:

– Oval = start/stop symbol; rectangle = process symbol; parallelogram = input/output symbol

• Diamond symbol is called decision symbol

– Used to represent condition (decision) in selection and repetition structures

• Selection structures have one flowline leading in and two leading out

– “T” line leading out points to true path

– “F” line leading out points to false path

Flowcharting a Selection Structure

(cont’d)

Figure 5-4 Flowchart showing a single-

alternative selection structure

(cont’d)

Figure 5-5 Flowchart showing a dual-alternative selection structure

• The if (and else) statement is used to code most selection structures in C++

• Syntax

if (condition)

one or more statements (true path)

one or more statements (false path)]

• Keyword if and condition are required

• Portion in brackets (else clause) is optional

– Only used for dual-alternative selection structures

Coding a Selection Structure in C++

• Programmer must supply condition and statements in true (and, optionally, false) path

• If path contains more than one statement, must be entered as a statement block (enclosed in {})

• Good programming practice to put comment at end of clause (example: //end if)

– Makes program easier to read and understand

• The condition must be a Boolean expression

– May contain variables, constants, arithmetic operators, comparison operators, and logical operators

(cont’d.)

Figure 5-6 How to use the if statement

(cont’d.)

Figure 5-6 How to use the if statement (cont’d)

(cont’d.)

• Comparison operators are used to compare two values that have the same data type

– less than (<)

– less than or equal to (<=)

– greater than (>)

– greater than or equal to (>=)

– equal to (==)

– not equal to (!=)

• No spaces between dual-character symbols

Comparison Operators

• Have precedence numbers like arithmetic operators

• <, <=, >, and >= have precedence value 1

• == and != have precedence value 2

• Lower precedence evaluated first

• Equal precedence evaluated left to right

• Parentheses used to override precedence order

Comparison Operators (cont’d.)

• Expressions with comparison operators always evaluate to Boolean values

• Don’t confuse equality operator (==) with assignment operator (=)

• Don’t use equality (==) or inequality operator (!=) to compare real numbers

– Real numbers cannot be stored exactly

– Instead, test that absolute value of their difference is within some small threshold

Figure 5-7 How to use comparison operators in an if statement’s condition

Figure 5-8 Evaluation steps for an expression containing

arithmetic and comparison operators

• Example program (next slide) takes in two integers, swaps them if first is greater, and then prints out lower number, followed by higher number

• Uses single-alternative selection structure with statement block in true path

• Creates temporary variable to accomplish swap

• Temp variable can only be used in statement block in which it is declared; called a local variable

Swapping Numeric Values

Figure 5-9 IPO chart information and C++

instructions for the swapping program

Swapping Numeric Values (cont’d.)

Figure 5-10 Illustration of the swapping concept

Figure 5-11 Flowchart for the swapping program

Figure 5-12 Sample run of the swapping program

• Example program (next slide) displays the sum or difference of two numbers entered by the user

• Choice of addition or subtraction is entered by user as well

• Uses a dual-alternative selection structure

Displaying the Sum or Difference

(cont’d.)

instructions for the sum or difference program

Figure 5-14 Flowchart for sum or difference program

(cont’d.)

Figure 5-15 Sample run of the sum or difference program

(cont’d.)

• Logical operators allow you to combine two or more conditions (sub-conditions) into one compound condition

• Also called as Boolean operators (always evaluate to true or false)

• Two most common are And (&&) and Or (||)

• All sub-conditions must be true for a compound condition using And to be true

• Only one of the sub-conditions must be true for a compound condition using Or to be true

Logical Operators

• And evaluated before Or in an expression

• Logical operators evaluated after arithmetic and comparison operators

• Parentheses can override precedence ordering

• Truth tables summarize how computer evaluates logical operators

• Only necessary sub-conditions are evaluated; called short-circuit evaluation

– Example: if first sub-condition in an And clause is false, second sub-condition need not be evaluated

Logical Operators (cont’d.)

Figure 5-16 How to use logical operators in an if statement’s condition

Figure 5-16 How to use logical operators in an if statement’s condition (cont’d)

Figure 5-17 Truth tables for the logical operators

• Two example problem descriptions are given, and truth tables for And and Or operators are used to find appropriate sub-conditions and logical operators

• Calculate bonus for A-rated salespeople with monthly sales greater than $5000

rating == ‘A’ && sales > 5000

• Send letter to all A-rated and B-rated salespeople

rating == ‘A’ || rating == ‘B’

Using the Truth Tables

• Example problem description is given in which the gross pay of an employee must be calculated

• Program must verify that number of hours worked is between 0 and 40

• Process of verifying that input data is within expected range is known as data validation

• Program outputs gross pay if the number of hours worked is valid and is an error message otherwise

Calculating Gross Pay

Calculating Gross Pay (cont’d.)

Figure 5-18 Examples of C++

instructions for the gross pay program

Calculating Gross Pay (cont’d.)

Figure 5-19 First sample run of

the gross pay program’s code

Figure 5-20 Second sample run of

the gross pay program’s code

• Example problem description is given in which program must output “Pass” if user enters ‘P’ or ‘p’, and “Fail” otherwise

• Character comparisons are case sensitive in C++

• Program must check separately whether the user entered ‘P’ or ‘p’

• Dual-alternative selection structure is used to implement program

• Compound condition with Or operator is used to perform check

Pass/Fail Program

Figure 5-21 Examples of C++ instructions for the Pass/Fail program

Pass/Fail Program (cont’d)

Pass/Fail Program (cont’d.)

Figure 5-22 First sample run of

the Pass/Fail program’s code

Figure 5-23 Second sample run of

the Pass/Fail program’s code

Figure 5-24 Listing and an example of

arithmetic, comparison, and logical operators

Summary of Operators

• toupper and tolower functions used to convert characters between uppercase and lowercase

• toupper function temporarily converts a character to uppercase; tolower function temporarily converts a character to lowercase

• Syntax is toupper(charVariable) and tolower(charVariable)

• Item between parentheses in a function’s syntax is called an argument – information the function needs to perform its task

Converting a Character to Uppercase

or Lowercase

• Each function copies the character in its argument to a temporary location in internal memory, converts the character to the appropriate case, and returns the temporary character

• Neither function changes the contents of its argument, but rather, changes the temporary variable

or Lowercase (cont’d.)

Figure 5-25 How to use the toupper and tolower functions

or Lowercase (cont’d.)

• Real numbers are displayed in either fixed-point or scientific (e) notation

• Small real numbers (six or less digits before decimal place) displayed in fixed-point notation

– Example: 1,234.56 displayed as 1234.560000

• Large real numbers (more than six digits before decimal place) displayed in e notation

– Example: 1,225,000.00 displayed as 1.225e+006

• Purpose of program determines appropriate format

Formatting Numeric Output

• Stream manipulators allow control over formatting

• fixed stream manipulator displays real numbers in fixed-point notation

• scientific stream manipulator displays real numbers in e notation

• Stream manipulator must appear in a cout statement before numbers you want formatted

• Manipulator can appear by itself in a cout statement or can be included with other information

Formatting Numeric Output (cont’d.)

• Manipulator remains in effect until end of program execution or until another manipulator is processed

• Numbers formatted with fixed stream manipulator always have six numbers to the right of the decimal place

– Number is padded with zeros if there aren’t six digits

• Example: 123.456 is displayed as 123.456000

– Number is rounded and truncated if there are more than six digits

• Example: 123.3456789 is displayed as 123.345679

• setprecision stream manipulator controls number of decimal places

• Syntax setprecision(numberOfDecimalPlaces)

• You can include setprecision and fixed manipulators in the same cout statement

• Definition of setprecision manipulator contained in iomanip file

• Program must contain #include <iomanip> directive to use setprecision manipulator

Figure 5-26 How to use the fixed

and scientific stream manipulators

Figure 5-27 How to use the setprecision stream manipulator

• Selection structure used when you want a program to make a decision before choosing next instruction

• Selection structure’s condition must evaluate to true or false

• In single-alternative and dual-alternative selection structures, the instructions followed when the condition is true are placed in the true path

• In dual-alternative selection structures, the instructions followed when the condition is false are placed in the false path

Summary

• A diamond (decision symbol) is used to represent a selection structure’s condition in a flowchart

• Each selection structure has one flowline going into the diamond and two coming out (“T” line represents the true path, and “F” line the false path)

• The if statement is used to code most selection structures

• True or false paths with more than one statement must be entered as a statement block (enclosed in {})

Summary (cont’d.)

• Good practice to end if and else statements with a comment (//end if)

• Comparison operators are used to compare values – Expressions using them evaluate to true or false

• Comparison operators have precedence ordering similar to arithmetic operators

• Don’t use == and != to compare real numbers

• Local variables can only be used in the statement block in which they are declared

Summary (cont’d.)

• Expressions with logical operators evaluate to true or false

• And (&&) and Or (||) are logical operators, which also have precedence

• Arithmetic operators are evaluated first in an expression, followed by comparison operators and then logical operators

• Character comparisons are case sensitive

• toupper and tolower functions temporarily convert a character to upper or lowercase

Summary (cont’d.)

• The fixed and scientific stream manipulators allow you to format real numbers

• The setprecision manipulator allows you to specify the number of decimal places that appear

• fixed and scientific are defined in the iostream file

• setprecision is defined in the iomanip file

Summary (cont’d.)

Figure 5-28 Program for Lab 5-1

• Plan and create an algorithm for the manager of the Willow Springs Health Club

• Currently, the if statement’s true path in Lab 5-2 handles valid data, while its false path handles invalid data

• Modify the program so that invalid data is handled in the true path, and valid data is handled in the false path

Lab 5-3: Modify

• Desk-check the code shown in Figure 5-34 using the letter ‘P’

• Why is it inefficient? How could you improve it?

Lab 5-4: Desk-Check

• Test the program using codes 1, 2, and 3

• Debug the program

Lab 5-5: Debug

Seventh Edition

Chapter 6:

c++programming

computer programming

language machine languages

programming chapter

programmers job programmers

edition chapter

trained programmers

computers programmers

type of machine

Documents

programming language (c) - columbia...

c# programming

programming in c/c++ 2006 lecture 1 -...

programming c-c++

c/c++ programming

c programming

c++ programming

introduction to programming c programming

c programming language - modular programming

programming in c & c++

eng1410 c programming: topic #2 “c programming: variables

c-programming-embedded c

c++ - intermediate c++ programming

c# programming iv-7 -...

scsa1202 programming with c and c++ unit1 basics of c...

programming c++

c (programming in c)

embedded programming in c/c++: lesson-1: programming

12 (c programming) (korean) appendix-b c standard...